テンプレートクラスのメンバ関数の特化を書くことは可能ですか？

Question

template <class T, bool flag> 
class A 
{ 
    //... 
    void f() 
    { 
     std::cout << "false" << std::endl; 
    } 
    //... 
}; 

template<class T> 
void A<T, true>::f<T, true>() 
{ 
    std::cout << "true" << std::endl; 
} 

上記のコードは間違っていてコンパイルされませんが、私は何をしようとしているのか分かります。だから私はそれをどうすればいいのですか？

Answer 1

クラスのメソッドを1つだけ特殊化することはできません。通常、テンプレートのネストされたクラスを同じTで解決できます。

template <class T, bool flag> 
class A 
{ 
    //... 
    template <class Q, bool flag> 
    class F_Helper 
    { 
     void operator()() 
     { 
      std::cout << "false" << std::endl; 
     } 
    }; 

    template <class Q> 
    class F_Helper<Q, true> 
    { 
     void operator()() 
     { 
      std::cout << "true" << std::endl; 
     } 
    }; 

    F_Helper<T> f; 
    //... 
}; 

明らかにあなたは、囲むクラスの thisポインタにアクセスする必要がない場合より多くの定型が必要とされているビット。

Answer 2

あなたはテンプレートクラス全体を特化することができます - Ideone link

#include <iostream> 

template <class T, bool flag> 
class A 
{ 
    //... 
    void f() 
    { 
     std::cout << "false" << std::endl; 
    } 
    //... 
}; 

template<class T> 
class A<T, true> 
{ 
    //... 
    void f() 
    { 
     std::cout << "true" << std::endl; 
    } 
    //... 
}; 

Answer 3

あなたがクラス全体特化する必要があります：あなたはメンバ関数を特化することができ、他の回答が言うに

#include <iostream> 

template <class T, bool flag> 
class A 
{ 
public: 
    void f() 
    { 
     std::cout << "false" << std::endl; 
    } 
}; 

template<class T> 
class A<T,true> 
{ 
public: 
    void f() 
    { 
     std::cout << "true" << std::endl; 
    } 
}; 

void main() 
{ 
    A<int, false> a; 
    a.f(); 

    A<int, true> b; 
    b.f(); 
} 

Answer 4

反しをクラステンプレートの有効な

template<typename T> 
void A<T, true>::f() 
{ 
    std::cout << "true" << std::endl; 
} 

が部分的にそのクラスのテンプレートの特定の引数のクラステンプレートのメンバーを専門にされないように、：何しようとすることは有効ではありません

template<> 
void A<int, true>::f() 
{ 
    std::cout << "true" << std::endl; 
} 

しかし、あなたは、すべてのテンプレート引数を提供する必要があります「<T, true>のAの部分特殊化のメンバー関数 'f'を定義する」を意味します。そのような部分的な特殊化がないので、コンパイラはエラーになります。あなたはすべての引数を提供できない場合

template <class T, bool flag> 
class A 
{ 
    template<typename, bool> struct params { }; 

    void f() 
    { 
     f(params<T, flags>()); 
    } 

    template<typename U> 
    void f(params<U, true>) { 
     std::cout << "true" << std::endl; 
    } 

    template<typename U, bool flag1> 
    void f(params<U, flag1>) { 
     std::cout << "dunno" << std::endl; 
    } 
};