テンプレートの部分特殊化

template<class T1, class T2, int I>
class A {};            // プライマリテンプレート
 
template<class T, int I>
class A<T, T*, I> {};  // #1: T2 が T1 へのポインタである場合の部分特殊化
 
template<class T, class T2, int I>
class A<T*, T2, I> {}; // #2: T1 がポインタである場合の部分特殊化
 
template<class T>
class A<int, T*, 5> {}; // #3: T1 が int、 T2 がポインタ、 I が 5
                        //     である場合の部分特殊化
 
template<class X, class T, int I>
class A<X, T*, I> {};   // #4: T2 がポインタである場合の部分特殊化

namespace N {
    template<class T1, class T2> class Z { }; // プライマリテンプレート
}
using N::Z; // プライマリテンプレートを参照します。
namespace N {
    template<class T> class Z<T, T*> { }; // 部分特殊化
}
Z<int,int*> z; // 名前探索によって N::Z のプライマリテンプレートが発見されます。
               // そして、 T = int の部分特殊化が使用されます。

template<int I, int J, class T> struct X { }; // プライマリテンプレート
template<int I, int J>          struct X<I, J, int> {
        static const int s = 1;
}; // 部分特殊化 #1
// #1 に対する架空の関数テンプレート:
// template<int I, int J> void f(X<I, J, int>); #A
 
template<int I>                 struct X<I, I, int> {
        static const int s = 2;
}; // 部分特殊化 #2
// #2 に対する架空の関数テンプレート:
// template<int I>        void f(X<I, I, int>); #B
 
int main()
{
    X<2, 2, int> x; // #1 と #2 の両方にマッチします。
// 架空の関数テンプレートに対する半順序:
// #B から #A: void(X<U1, U1, int>) から void(X<I,J,int>) : 推定成功
// #A から #B: void(X<U1, U2, int>) から void(X<I,I,int>) : 推定失敗
// #B がより特殊化されています。
// 実体化される特殊化は #2 です。
    std::cout << x.s << '\n'; // 2 を表示します。
}

template<class T, int I>  // プライマリテンプレート
struct A {
    void f(); // メンバの宣言
};
 
template<class T, int I>
void A<T,I>::f() { } // プライマリテンプレートのメンバの定義
 
// 部分特殊化
template<class T>
struct A<T,2> {
    void f();
    void g();
    void h();
};
 
// 部分特殊化のメンバ
template<class T>
void A<T,2>::g() { }
 
// 部分特殊化のメンバの
// 明示的 (完全) 特殊化
template<>
void A<char,2>::h() {}
 
int main() {
    A<char,0> a0;
    A<char,2> a2;
    a0.f(); // OK、プライマリテンプレートのメンバの定義を使用します。
    a2.g(); // OK、部分特殊化のメンバの定義を使用します。
    a2.h(); // OK、部分特殊化のメンバの
            // 完全特殊化された定義を使用します。
    a2.f(); // エラー、部分特殊化 A<T,2> の f() には定義がありません
            // (プライマリテンプレートは使用されません)。
}

template<class T> struct A { // 囲っているクラステンプレート
  template<class T2>
  struct B {}; // プライマリメンバテンプレート
  template<class T2>
  struct B<T2*> {}; // メンバテンプレートの部分特殊化
};
 
template<>
template<class T2>
struct A<short>::B {}; // プライマリメンバテンプレートの完全特殊化
                       // (部分特殊化を無視します)
 
A<char>::B<int*> abcip; // 部分特殊化 (T2=int) を使用します。
A<short>::B<int*> absip; // プライマリテンプレートの完全特殊化を使用します (部分特殊化を無視します)
A<char>::B<int> abci; // プライマリテンプレートを使用します。