テンプレート仮引数とテンプレート実引数

// 型テンプレート仮引数を持つテンプレートの宣言。
template<class> class My_vector;
template<class = void> struct My_op_functor;
template<typename...> class My_tuple;

template<typename T> class my_array {};
 
// 2個の型テンプレート仮引数と1個のテンプレートテンプレート仮引数。
template<typename K, typename V, template<typename> typename C = my_array>
class Map
{
    C<K> key;
    C<V> value;
};

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<class 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; // エラー、 TT の第1仮引数が型テンプレート仮引数であるのに対して、
                // 17 は型を表さないため、
                // C は部分特殊化の TT にマッチしません。
eval<D<int, 17>> eD; // エラー、 TT の第2仮引数が型パラメータパックであるのに対して、
                     // 17 は型を表さないため、
                     // D は部分特殊化の TT にマッチしません。
eval<E<int, float>> eE; // エラー、 E の第3仮引数 (デフォルト値を使用) は非型であるため、
                        // E は部分特殊化の TT にマッチしません。

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; // CWG 150 適用後の C++17 では OK
         // それより前ではエラー (正確なマッチでない)
X<C> xc; // CWG 150 適用後の C++17 では 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 は、デフォルト付きの
// 型テンプレート仮引数1個から構成される、仮引数リストを持ちます。
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 は protected です。