Czy można użyć std :: enable_if, aby wybrać specjalizację szablonów członków?

Question

Biorąc pod uwagę deklarację klasy

class A { 
    template <typename T> T foo(); 
}; 

Chciałbym specjalizować A::foo różnych rodzajów (int, ...) i zajęcia typu (POD, non-POD) z T. Niestety, nie wydaje mi się, aby użyć tego ostatniego. Dodaje się nie kompiluje:

template <> int A::foo<int>(); // OK 

template <typename T> 
typename std::enable_if<is_pod<T>::value, T>::type foo(); // <<<< NOT OK! 

template <typename T> 
typename std::enable_if<!is_pod<T>::value, T>::type foo(); // <<<< NOT OK! 

Problem jest prawdopodobnie ze względu na std::enable_if<...> rzeczy będącej częścią podpisu funkcji, a ja nie ogłoszono takiego członka wewnątrz A. Jak więc mogę wyspecjalizować członka szablonu na podstawie cech typu?

Answer 1

widzę żadnego powodu specjalizacji tutaj, przeciążenia funkcja wydaje się wystarczające w moim umyśle.

struct A 
{ 
    template <typename T> 
    typename std::enable_if<std::is_integral<T>::value, T>::type foo() 
    { 
     std::cout << "integral" << std::endl; 
     return T(); 
    } 

    template <typename T> 
    typename std::enable_if<!std::is_integral<T>::value, T>::type foo() 
    { 
     std::cout << "not integral" << std::endl; 
     return T(); 
    } 
} 

Podczas sprawdzania POD POD lub nie, trzeba tylko te dwie możliwości, a więc funkcja bardziej ogólny i nie jest konieczna (i niedozwolone, ponieważ byłoby niejednoznaczne). Potrzebujesz więcej? Możesz sprawdzić typy jawne bez specjalizacji z pomocą std::enable_if<std::is_same<int, T>::value, T>::type.

Answer 2

Wolałbym do przodu to do struktury, która ma obsługiwać to dobrze:

#include <type_traits> 
#include <iostream> 

template <typename T, typename = void> 
struct FooCaller; 

class A { 
public: 
    template <typename T> 
    T foo() { 
     // Forward the call to a structure, let the structure choose 
     // the specialization. 
     return FooCaller<T>::call(*this); 
    } 
}; 

// Specialize for PODs. 
template <typename T> 
struct FooCaller<T, typename std::enable_if<std::is_pod<T>::value>::type> { 
    static T call(A& self) { 
     std::cout << "pod." << std::endl; 
     return T(); 
    } 
}; 

// Specialize for non-PODs.  
template <typename T> 
struct FooCaller<T, typename std::enable_if<!std::is_pod<T>::value>::type> { 
    static T call(A& self) { 
     std::cout << "non-pod." << std::endl; 
     return T(); 
    } 
}; 

// Specialize for 'int'. 
template <> 
struct FooCaller<int> { 
    static int call(A& self) { 
     std::cout << "int." << std::endl; 
     return 0; 
    } 
};