Come utilizzare enable_if per abilitare le funzioni di membro sulla base di parametro di modello di classe

Question

in codice:

template<class T> 
struct is_builtin 
{ 
    enum {value = 0}; 
}; 

template<> 
struct is_builtin<char> 
{ 
    enum {value = 1}; 
}; 

template<> 
struct is_builtin<int> 
{ 
    enum {value = 1}; 
}; 

template<> 
struct is_builtin<double> 
{ 
    enum {value = 1}; 
}; 

template<class T> 
struct My 
{ 
    typename enable_if<is_builtin<T>::value,void>::type f(T arg) 
    { 
     std::cout << "Built-in as a param.\n"; 
    } 


    typename enable_if<!is_builtin<T>::value,void>::type f(T arg) 
    { 
     std::cout << "Non - built-in as a param.\n"; 
    } 
}; 

struct A 
{ 
}; 

int main() 
{ 
    A a; 
    My<int> m; 
    My<A> ma; 
    m.f(1); 
    ma.f(a); 
    return 0; 
} 

sto ottenendo un errore:

error C2039: 'type' : is not a member of 'std::tr1::enable_if<_Test,_Type>'  

Ovviamente non capisco come utilizzare enable_if. Quello che stavo pensando è che posso abilitare una o la seconda funzione membro da un insieme di funzioni membro durante il tempo di compilazione, ma non funziona. Qualcuno potrebbe spiegarmi come farlo correttamente?
Modificato
Quello che davvero non riesco a capire è perché non ci sia typedef in uno di quelli def. Il compilatore non riesce a trovarlo e non lo compila.

Answer 1

Non è possibile utilizzare i parametri del modello di classe per ottenere SFINAE per le funzioni membro.

Si sia bisogno di

• rendere la funzione di membro di un modello di funzione membro invece e utilizzare enable_if sui parametri di modello del modello di funzione di membro o

• mossa la funzione di membro f in una classe politica e di specializza il modello di classe usando enable_if.

Answer 2

enable_if prevede una metafunzione. Per usare un bool è necessario enable_if_c. Sono sorpreso che non stai ricevendo errori che spiegano quel problema.

È possibile correggere la metafunzione dichiarando un typedef 'tipo' all'interno che è semplicemente se stesso. Quindi è possibile utilizzare boost::enable_if<is_builtin<T>>::type

Answer 3

Ecco come funziona (si noti che per comodità ho sostituito il vostro is_builtin tratto con std::is_arithmetic e usato ulteriormente C++ 11 roba, ma funziona in qualsiasi modo):

template<class T> 
struct My 
{ 
    template<typename T_ = T, std::enable_if_t<std::is_arithmetic<T_>::value>* = nullptr> 
    void f(T_ arg) 
    { 
     std::cout << "Built-in as a param.\n"; 
    } 

    template<typename T_ = T, std::enable_if_t<!std::is_arithmetic<T_>::value>* = nullptr> 
    void f(T_ arg) 
    { 
     std::cout << "Non - built-in as a param.\n"; 
    } 
}; 

DEMO

la parte cruciale è quello di portare il parametro di modello nel contesto immediato utilizzando una funzione predefinita parametro di template T_ che è uguale al parametro modello di classe T. Per maggiori dettagli, vedi this question.

Answer 4

È possibile correggere il codice utilizzando modificati enable_if

template < typename T > 
struct __Conflict {}; 

template <bool B, class T = void> 
struct __enable_if { typedef __Conflict<T> type; }; 

template <class T> 
struct __enable_if<true, T> { typedef T type; }; 

Esempio di utilizzo:

template <typename T> 
class Lazy 
{ 
public: 
    void _ctor(bool b); 
    void _ctor(typename __enable_if<!std::is_same<T, bool>::value, T>::type); 
}; 

template <typename T> 
void Lazy<T>::_ctor(bool b) 
{ 
    std::cout << "bool " << b << std::endl; 
}; 

template <typename T> 
void Lazy<T>::_ctor(typename __enable_if<!std::is_same<T, bool>::value, T>::type t) 
{ 
    std::cout << "T " << t << std::endl; 
}; 

int main(int argc, char **argv) 
{ 
    Lazy<int> i; 
    i._ctor(10); 
    i._ctor(true); 

    Lazy<bool> b; 
    b._ctor(true); 

    return 0; 
}