Is it possible to define an alias for a template-template parameter?

Question

I'm experimenting with template-template for fun. I have the following class:

template<template<class> class T, typename R> class Unit
{    
    using FullType = T<R>;
    using Ratio = R;
    //using Type = T;

    ...
};

I have define type R and T<R> as member-types Ratio and FullType. Is it possible to alias T as Type ?

The commented line above give me the following errors on g++ 4.7:

expected nested-name-specifier before 'Type'
using-declaration for non-member at class scope
expected ';' before '=' token
expected unqualified-id before '=' token

I tried some more or less random syntaxes, but none of them compiled.

Thanks !

Answer 1

You cannot make an alias for T. The following was discussed in the committee to make an alias for T (because a very late C++11 draft contained notes that stated that it is an alias for T which a Defect Report cleaned up).

// Courtesy of @KerrekSB
template <template <typename> class T, typename R> class Unit
{
    template <typename U> using MyTemplate = T<U>;
    // ...

    // use e.g. MyTemplate<int> to get T<int>
};

Note while MyTemplate<int> is the same type as T<int>, that MyTemplate is not the same as T. The wording at http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1286 was supposed to change that, but in the last meeting it was considered to be a very special machinery that doesn't really fit what alias templates turned out to be (own templates), and it was pushed back to review. To get that effect, a using MyTemplate = T; in future may fit the bill (if proposed and accepted, of course).

Answer 2

Since T isn't a type, the question as asked doesn't make sense. However, you can make an alias for T, like:

template <template <typename> class T, typename R> class Unit
{
    template <typename U> using MyTemplate = T<U>;
    // ...

    // use e.g. MyTemplate<int> to get T<int>
};

Pre-C++11 you would need something more notationally involved as outlined in this answer of mine (and used, for example, in the standard library by the standard allocator's rebind mechanic.)