Cómo utilizar enable_if para permitir funciones miembro sobre la base de parámetro de plantilla de clase

Question

En código:

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

Recibo un error:

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

Obviamente, yo no entiendo cómo utilizar enable_if. Lo que estaba pensando era que puedo habilitar una o la segunda función miembro de un conjunto de funciones miembro durante el tiempo de compilación, pero no funciona. ¿Alguien podría explicarme cómo hacerlo correctamente?
Editado
Lo que realmente no puedo entender es por qué no hay typedef en uno de esos def. El compilador no puede encontrarlo y no lo compilará.

Answer 1

No puede usar los parámetros de plantilla de clase para obtener SFINAE para las funciones de miembro.

o hay que hacer

• hacen la función de miembro de una plantilla de función miembro de su lugar y utilizar enable_if en los parámetros de plantilla de la plantilla función miembro o

• movimiento la función miembro f en una clase política y especialice la plantilla de clase usando enable_if.

Answer 2

enable_if espera una metafunción. Para usar un bool necesita enable_if_c. Me sorprende que no estés recibiendo errores explicando ESE problema.

Puede corregir su metafunción declarando un typedef 'type' dentro que es simplemente él mismo. A continuación, puede utilizar boost::enable_if<is_builtin<T>>::type

Answer 3

Así es como funciona (nótese que por conveniencia Substituí su is_builtin rasgo con std::is_arithmetic y se utiliza más de C++ 11 cosas, pero funciona de ninguna manera):

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 crucial es poner el parámetro de plantilla en el contexto inmediato utilizando un parámetro de plantilla de función por defecto T_ que es igual al parámetro de plantilla de clase T. Para más detalles, vea this question.

Answer 4

Usted puede fijar su código utilizando modificados 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; }; 

Ejemplo de uso:

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