メンバテンプレート

struct A {
    template<class T> struct B;         // プライマリメンバテンプレート
    template<class T> struct B<T*> { }; // OK、部分特殊化
//  template<> struct B<int*> { };      // エラー、完全特殊化
};
template<> struct A::B<int*> { };       // OK
template<class T> struct A::B<T&> { };  // OK

template<typename T1>
struct string {
    // メンバテンプレート関数
    template<typename T2>
    int compare(const T2&);
    // コンストラクタもテンプレートにできます
    template<typename T2>
    string(const std::basic_string<T2>& s) { /*...*/ }
};
// string<T1>::compare<T2> のクラス外側の定義
template<typename T1> // 囲っているクラステンプレート用
template<typename T2> // メンバテンプレート用
int string<T1>::compare(const T2& s) { /* ... */ }

class Base {
    virtual void f(int);
};
struct Derived : Base {
    // このメンバテンプレートは Base::f をオーバーライドしません。
    template <class T> void f(T);
 
    // 非テンプレートメンバのオーバーライドがテンプレートを呼ぶことはできます。
    void f(int i) override {
         f<>(i);
    }
};

template<typename T>
struct A {
    void f(int); // 非テンプレートメンバ
 
    template<typename T2>
    void f(T2); // メンバテンプレート
};
 
// メンバテンプレートの定義
template<typename T>
template<typename T2>
void A<T>::f(T2)
{
    // 何らかのコード
}
 
int main()
{
    A<char> ac;
    ac.f('c'); // テンプレート関数 A<char>::f<char>(int) を呼びます。
    ac.f(1);   // 非テンプレート関数 A<char>::f(int) を呼びます。
    ac.f<>(1); // テンプレート関数 A<char>::f<int>(int) を呼びます。
}

struct X {
    template<class T> T good(T n);
    template<class T> T bad(T n);
};
 
template<class T> struct identity { using type = T; };
 
// OK、同等な宣言です。
template<class V>
V X::good(V n) { return n; }
 
// エラー、 X の内側のどの宣言とも同等でありません。
Error: not equivalent to any of the declarations inside X
template<class T>
T X::bad(typename identity<T>::type n) { return n; }

struct A {
    template<typename T>
    operator T*(); // 任意の型のポインタへの変換
};
 
// クラス外側の定義
template<typename T>
A::operator T*() {return nullptr;}
 
// char* に対する明示的特殊化
template<>
A::operator char*() {return nullptr;}
 
// 明示的実体化
template A::operator void*();
 
int main() {
    A a;
    int* ip = a.operator int*(); // 明示的な A::operator int*() の呼び出し
}