Realizar diferentes métodos basados ​​en la variable de plantilla tipo

Question

¿Hay alguna forma de determinar el tipo de variable pasada a una plantilla y llamar a una función según si es int o std::string, etc.?

Por ejemplo

template <class T> 
struct Jam 
{ 
    Jam(T *var) 
    { 
     if (typeid(var) == typeid(std::string*) 
       *var = "Hello!"; 
     else if (typeid(var) == typeid(int*) 
       *var = 25; 
    } 
}; 

Cuando trato de usar el código, me sale un error invalid conversion from const char* to int. Sospecho que esto se debe a que el compilador "expande" la plantilla en funciones separadas y cuando especifiqué una nueva instancia de la estructura throw Jam<std::string>(&setme); detectó la declaración var* = 25 y se negó a compilar.

¿Hay una forma adecuada de hacerlo? Tal vez con macro guardias? Gracias.

Answer 1

Uso función regular la sobrecarga en su lugar:

template <class T> 
struct Jam 
{ 
    Jam(std::string* var) 
    { 
     *var = "Hello!"; 
    } 

    Jam(int* var) 
    { 
     *var = 25; 
    } 
}; 

a menos que quiera especializarse en el tipo T utilizado para crear instancias de Jam. En ese caso, usted haría:

template<> 
struct Jam<std::string> 
{ 
    Jam(std::string* var) 
    { 
     *var = "Hello!"; 
    } 
}; 

template<> 
struct Jam<int> 
{ 
    Jam(int* var) 
    { 
     *var = 25; 
    } 
}; 


template<typename T> 
struct Jam 
{ 
    Jam(T* var) 
    { 
     // every other type 
    } 
}; 

Answer 2

Busque "especialización de plantilla parcial".

Take Jam() del cuerpo 's de Jam {}:

template <class T> 
struct Jam 
{ 
    Jam(T *var); 
}; 

Ahora escribe dos cuerpos:

Jam<int>::Jam(int *var) { 
    // stuff 
} 

Jam<std::string>::Jam(std::string *var) { 
    // stuff 
} 

(Advertencia:. Oxidada C++, pero eso es por lo general la forma de hacerlo.)

Nueva pregunta: Si necesita pato-tipado, ¿por qué está usando C++ en absoluto? Cambiaría a Ruby y guardaría el C++ para los complementos que necesitan velocidad. ¡Pero C++ seguirá soportando diseños elegantes, con más trabajo!