Member templates

struct A
{
    template<class T> struct B;        // プライマリメンバーテンプレート
    template<class T> struct B<T*> {}; // OK: 部分特殊化
//  template<> struct B<int*> {};      // CWG 727経由でOK: 完全特殊化
};
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>(char) を呼び出す
    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内部のどの宣言とも等価ではない
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*() の明示的呼び出し
}