Eseguire diversi metodi basati sul tipo di variabile modello

Question

Esiste un modo per determinare il tipo di variabile passato a un modello e chiamare una funzione basata su se è unoo std::string ecc.?

Per esempio

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

Quando provo ad utilizzare quel codice, ottengo un errore invalid conversion from const char* to int. Sospetto che ciò avvenga perché il compilatore "espande" il modello in funzioni separate e quando ho specificato una nuova istanza della struttura throw Jam<std::string>(&setme); ha rilevato l'istruzione var* = 25 e si è rifiutata di compilare.

Esiste un modo corretto per farlo? Forse con le macro guardie? Grazie.

Answer 1

Utilizzare la funzione normale sovraccarico invece:

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

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

meno che non si desidera specializzarsi sul tipo T utilizzato per istanziare Jam. In tal caso, farei:

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

Cercare "specializzazione modello parziale".

Prendere Jam() 's corpo fuori Jam {}:

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

Ora scrivere due corpi:

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

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

(Attenzione:. Rusty C++ Ma è in generale come lo fai.)

Nuova domanda: se hai bisogno di digitazione anatra, perché stai usando il C++? Passerei a Ruby e salverò il C++ per i plug-in che richiedono velocità. Ma C++ continuerà a supportare progetti eleganti, con più lavoro!