模板形参与模板实参

// 对上面所示模板的声明：
template<class> class My_vector;
template<class = void> struct My_op_functor;
template<typename...> class My_tuple;

template<typename T> class my_array {};
 
// 两个类型模板形参和一个模板模板形参：
template<typename K, typename V, template<typename> typename C = my_array>
class Map
{
    C<K> key;
    C<V> value;
};

template<class T, int N>
class Y {
    int T;                 // 错误：重声明模板形参
    void f()
    {
        char T;            // 错误：重声明模板形参
    }
};
 
template<class X> class X; // 错误：重声明模板形参

template<class T>
struct A {
    struct B {};
    typedef void C;
    void f();
    template<class U> void g(U);
};
 
template<class B>
void A<B>::f()
{
    B b;            // A 的 B ，不是模板形参
}
 
template<class B>
template<class C>
void A<B>::g(C)
{
    B b;            // A 的 B ，不是模板形参
    C c;            // 模板形参 C ，不是 A 的 C
}

namespace N {
    class C {};
    template<class T>
    class B {
        void f(T);
    };
}
template<class C>
void N::B<C>::f(C)
{
    C b;            // C 是模板形参，非 N::C
}

struct A {
    struct B {};
    int C;
    int Y;
};
 
template<class B, class C>
struct X : A {
    B b;            // A 的 B
    C b;            // 错误： A 的 C 不是类型名
};

template<class T> void f(); // #1
template<int I> void f(); // #2
void g() {
    f<int()>(); // "int()" 既是类型又是表达式，
                // 调用 #1 因为它被解释成类型
}

template<typename T> class X {}; // 类模板
 
struct A; // 不完整类型
typedef struct {} B; // 无名类型的类型别名
 
int main()
{
    X<A> x1; // ok：'A' 指名类型
    X<A*> x2; // ok：'A*' 指名类型
    X<B> x3; // ok：'B' 指名类型
}

template<typename T> class A { int x; }; // 主模板
template<typename T> class A<T*> { long x; }; // 部分特化
 
// 带有模板模板形参 V 的类模板
template<template<typename> class V> class C
{
    V<int> y; // 使用主模板
    V<int*> z; // 使用部分特化
};
 
C<A> c; // c.y.x 类型为 int，c.z.x 类型为 long

template<typename T> struct eval; // 主模板 
 
template<template<typename, typename...> class TT, typename T1, typename... Rest>
struct eval<TT<T1, Rest...>> {}; // eval 的部分特化
 
template<typename T1> struct A;
template<typename T1, typename T2> struct B;
template<int N> struct C;
template<typename T1, int N> struct D;
template<typename T1, typename T2, int N = 17> struct E;
 
eval<A<int>> eA; // ok：匹配 eval 的部分特化
eval<B<int, float>> eB; // ok：匹配 eval 的部分特化
eval<C<17>> eC; // 错误：C 在部分特化中不匹配 TT，因为 TT 的首个形参是类型模板形参
                // 而 17 不指名类型
eval<D<int, 17>> eD; // 错误：D 在部分特化中不匹配 TT，
                     // 因为 TT 的第二形参是类型形参包，而 17 不指名类型
eval<E<int, float>> eE; // 错误：E 在部分特化中不匹配 TT
                        // 因为 E 的第三（默认）形参是非类型形参

template<class T> class A { /* ... */ };
template<class T, class U = T> class B { /* ... */ };
template <class ...Types> class C { /* ... */ };
 
template<template<class> class P> class X { /* ... */ };
X<A> xa; // OK
X<B> xb; // C++17 在 CWG 150 后 OK
         // 更早时为错误：非严格匹配
X<C> xc; // C++17 在 CWG 150 后 OK
         // 更早时为错误：非严格匹配
 
template<template<class ...> class Q> class Y { /* ... */ };
Y<A> ya; // OK
Y<B> yb; // OK
Y<C> yc; // OK
 
template<auto n> class D { /* ... */ }; // 注意：C++17
template<template<int> class R> class Z { /* ... */ };
Z<D> zd; // OK
 
template <int> struct SI { /* ... */ };
template <template <auto> class> void FA();  // 注意：C++17
FA<SI>();  // 错误

template<typename T1, typename T2 = int> class A;
template<typename T1 = int, typename T2> class A;
// 如上与如下相同：
template<typename T1 = int, typename T2 = int> class A;

template<typename T = int> class X;
template<typename T = int> class X {}; // 错误

// 类模板，带有默认实参的类型模板形参
template<typename T = float> struct B {};
 
// 模板模板形参 T 有形参列表，
// 它由一个带默认实参的类型模板形参组成
template<template<typename = float> typename T> struct A
{
    void f();
    void g();
};
 
// 类体外的成员函数模板定义
template<template<typename TT> class T>
void A<T>::f()
{
    T<> t; // 错误：TT 在作用域中无默认实参
}
template<template<typename TT = char> class T>
void A<T>::g()
{
    T<> t; // ok：t 为 T<char>
}

class B {};
 
template<typename T> class C
{
    protected:
        typedef T TT;
};
 
template<typename U, typename V = typename U::TT> class D: public U {};
 
D<C<B>>* d; // 错误：C::TT 为受保护