テンプレートの明示的 (完全) 特殊化

namespace N {
    template<class T> class X { /*...*/ }; // プライマリテンプレート。
    template<> class X<int> { /*...*/ }; // 同じ名前空間での特殊化。
 
    template<class T> class Y { /*...*/ }; // プライマリテンプレート。
    template<> class Y<double>; // double に対する特殊化の前方宣言。
}
template<>
class N::Y<double> { /*...*/ }; // OK、同じ名前空間での特殊化。

class String {};
template<class T> class Array { /*...*/ };
template<class T> void sort(Array<T>& v) { /*...*/ } // プライマリテンプレート。
 
void f(Array<String>& v) {
    sort(v); // sort() のプライマリテンプレートを用いて
             // sort(Array<String>&) を暗黙に実体化します。
 
template<>  // エラー、 sort(Array<String>&) を暗黙に実体化した後の明示的特殊化。
void sort<String>(Array<String>& v);

template<class T> class X; // プライマリテンプレート。
template<> class X<int>; // 特殊化 (宣言されているけれども定義されていません)。
X<int>* p; // OK、不完全型へのポインタ。
X<int> x; // エラー、不完全型のオブジェクト。

template<class T> class Array { /*...*/ };
template<class T> void sort(Array<T>& v); // プライマリテンプレート。
template<> void sort(Array<int>&); // T = int に対する特殊化。
// template<> void sort<int>(Array<int>&); と書く必要はありません。

template< typename T>
struct A {
    struct B {};  // メンバクラス。
    template<class U> struct C { }; // メンバクラステンプレート。
};
 
template<> // 特殊化。
struct A<int> {
    void f(int); // 特殊化のメンバ関数。
};
// 特殊化のメンバに対しては template<> を使用しません。
void A<int>::f(int) { /* ... */ }
 
template<> // メンバクラスの特殊化。
struct A<char>::B {
    void f();
};
// 特殊化されたメンバクラスのメンバに対しても template<> を使用しません。
void A<char>::B::f() { /* ... */ }
 
template<> // メンバクラステンプレートの特殊化。
template<class U> struct A<char>::C {
    void f();
};
 
// クラステンプレートとして特殊化された
// 明示的に特殊化されたメンバクラステンプレートのメンバを定義するときは
// template<> を使用します。
template<>
template<class U> void A<char>::C<U>::f() { /* ... */ }

template<> X Q<int>::x; // 静的メンバの宣言。
template<> X Q<int>::x (); // エラー、関数の宣言。
template<> X Q<int>::x {}; // デフォルト初期化された静的メンバの定義。

template<typename T>
struct A {
    void f(T); // メンバ (プライマリテンプレート内で宣言されている)。
    void h(T) {} // メンバ (プライマリテンプレート内で定義されている)。
    template<class X1> void g1(T, X1); // メンバテンプレート。
    template<class X2> void g2(T, X2); // メンバテンプレート。
};
 
// メンバの特殊化。
template<> void A<int>::f(int);
// クラス内で定義されていてもメンバを特殊化できます。
template<> void A<int>::h(int) {}
 
// クラスの外側におけるメンバテンプレートの定義。
template<class T>
template<class X1> void A<T>::g1(T, X1) { }
 
// メンバテンプレートの特殊化。
template<>
template<class X1> void A<int>::g1(int, X1);
 
// メンバテンプレートの特殊化。
template<>
template<> void A<int>::g2<char>(int, char); // X2 = char に対して。
// 同上 (テンプレートの実引数推定 (X1 = char) を使用しています)。
template<> 
template<> void A<int>::g1(int, char);

template<class T1> class A {
    template<class T2> class B {
        void mf();
    };
};
template<> template<> class A<int>::B<double>;
template<> template<> void A<char>::B<char>::mf();

template <class T1> class A {
    template<class T2> class B {
        template<class T3> void mf1(T3); // メンバテンプレート。
        void mf2(); // 非テンプレートメンバ。
     };
};
 
// 特殊化。
template<> // 特殊化される A のため。
template<class X> // 特殊化されない B のため。
class A<int>::B {
    template <class T> void mf1(T);
};
 
// 特殊化。
template<> // 特殊化される A のため。
template<> // 特殊化される B のため。
template<class T> // 特殊化されない mf1 のため。
void A<int>::B<double>::mf1(T t) { }
 
// エラー、 B<double> は特殊化されるメンバテンプレートであるため、
// その囲っている A も特殊化されなければなりません。
template<class Y>
template<> void A<Y>::B<double>::mf2() { }