상속 된 멤버 함수의 템플릿 전문화

Question

기본 클래스의 멤버 함수를 전문화하고 싶습니다. 그러나 컴파일되지 않습니다. 컴파일하는 대안을 아는 사람이 있습니까? 여기

이이 Foo<char>()에 전화를 제외하고, 컴파일

struct Base 
{ 
    template<typename T> 
    void Foo() 
    { 
     throw "Foo() is not defined for this type"; 
    } 
}; 

struct Derived : public Base 
{ 
    template<> 
    void Foo<int>() { cout << "Foo<int>()" << endl; } // compile error (cannot specialize members from a base class) 

    template<> 
    void Foo<double>() { cout << "Foo<double>()" << endl; } // compile error (cannot specialize members from a base class) 
}; 

Answer 1

예입니다

#include <iostream> 
#include <string> 
using namespace std; 

struct Base 
{ 
    template<typename T> 
    void Foo() 
    { 
     throw "Foo() is not defined for this type"; 
    } 
}; 

struct Derived : public Base 
{ 
    template<typename T> void Foo(); 
}; 

template<> 
void Derived::Foo<int>() { cout << "Foo<int>()" << endl; } 

template<> 
void Derived::Foo<double>() { cout << "Foo<double>()" << endl; } 

int main() 
{ 
    Derived derived; 

    // this is client code 
    derived.Foo<int>(); 
    derived.Foo<double>(); 
    derived.Foo<char>(); // this throws 
} 

당신이 Foo<char>()에 대한 호출을 원하는 경우 - 또는 유형은 특별히으로 전문하지 - 그러면 효과가 있습니다. 당신은 모든 종류의 일이 아닌 전문 구현을 원한다면, 당신은뿐만 아니라 Foo()의 비 전문 구현을 추가해야합니다

template<typename T> 
void Derived::Foo() { cout << "generic" << endl; } 

Answer 2

은 결국, 우리가 오버로드를 사용하여 해결했다. 여기

여기

struct Base 
{ 
    template<typename T> 
    class OfType {} 

    template<typename T> 
    void Foo(OfType<T>) { static_assert(false, "Foo is not implemented for this type. Please look in the compiler error for more details."); } 
}; 

struct Derived : public Base 
{ 
    using Base::Foo; 

    void Foo(OfType<int>) { // here comes logic for ints } 
    void Foo(OfType<double>) { // here comes logic for doubles } 
}; 

이의 대답의 코멘트보기 (알렉스와 토론에 대한 응답으로 Foo()

template<typename S> 
class ClassThatUsesFoo 
{ 
    private: S s; 

    template<typename T> 
    void Bar(T item) 
    { 
     s.Foo(Base::OfType<T>()); // this is the code that uses Foo 
     DoSomeStuffWithItem(item); 
    } 
}; 

void main() 
{ 
    ClassThatUsesFoo<Derived> baz; 
    baz.Bar(12); // this will internally use Foo for ints 
    baz.Bar(12.0); // this will use Foo for doubles 
    baz.Bar("hello world"); // this will give a verbose compile error 
} 

Answer 3

를 사용하는 클라이언트 코드의 예처럼 기본 클래스는 모습입니다 존 디 블링), 이것은 내가 의미 한 바입니다 (SSCCE) :

#include <iostream> 
using namespace std; 

struct Base 
{ 
    template<typename T> 
    void Foo() 
    { 
     //static_assert(false, "Foo() is not defined for this type"); 
     throw "Foo() is not defined for this type"; 
    } 
}; 
    // you can add as many specializations in Base as you like 
    template <> 
    void Base::Foo<char>() { cout << "Base::Foo<char>()" << endl; } 


struct Derived : public Base 
{ 
    // just provide a default implementation of Derived::Foo 
    // that redirects the call to the hidden Base::Foo 
    template < typename T > 
    void Foo() 
    { Base::Foo<T>(); } 
}; 
    // the specializations for Derived 
    template<> 
    void Derived::Foo<int>() { cout << "Foo<int>()" << endl; } 

    template<> 
    void Derived::Foo<double>() { cout << "Foo<double>()" << endl; } 


struct Derived_wo_specialization : public Base 
{ 
    /* nothing */ 
}; 


int main() 
{ 
    Derived d; 
    d.Foo<char>(); 
    d.Foo<double>(); 

    Derived_wo_specialization dws; 
    dws.Foo<char>(); 
    dws.Foo<double>(); 
}