Ist es möglich, std :: enable_if zu verwenden, um eine Mitgliedervorlagenspezialisierung auszuwählen?

Question

eine Klassendeklaration

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

Gegeben Ich mag würde A::foo für verschiedene Arten spezialisieren (int, ...) und Typklassen (POD, nicht-POD) von T. Leider kann ich std::enable_if nicht für letzteres verwenden. Die folgende lässt sich nicht kompilieren:

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! 

Die Frage an die std::enable_if<...> Sachen als Teil der Funktionssignatur wahrscheinlich ist, und dass ich nicht erklären, eine solche Mitglied innerhalb A. Wie kann ich ein Template-Mitglied basierend auf Typeigenschaften spezialisieren?

Answer 1

Ich sehe keinen Grund, hier zu spezialisieren, Überlastung die Funktion in meinem Kopf zu genügen scheint.

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(); 
    } 
} 

Wenn für POD oder ohne POD Kontrolle, haben Sie nur diese zwei Möglichkeiten, so eine allgemeinere Funktion nicht benötigt wird (und nicht erlaubt, weil es eindeutig ist). Du brauchst mehr als das? Sie können mit Hilfe von std::enable_if<std::is_same<int, T>::value, T>::type nach expliziten Typen ohne Spezialisierung suchen.

Answer 2

Ich würde nur weiterleiten zu einer Struktur, die diese gut im Griff hat:

#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; 
    } 
};