Modèle de fonction spécialisée pour std :: string et char *

Question

Comme le titre l'indique, je souhaite spécialiser un modèle de fonction pour les pointeurs de chaîne et de caractère, jusqu'à présent j'ai fait this mais je n'arrive pas à déterminer les paramètres de chaîne par référence .

#include <iostream> 
#include <string.h> 
template<typename T> void xxx(T param) 
{ 
std::cout << "General : "<< sizeof(T) << std::endl; 
} 

template<> void xxx<char*>(char* param) 
{ 
std::cout << "Char ptr: "<< strlen(param) << std::endl; 
} 

template<> void xxx<const char* >(const char* param) 
{ 
std::cout << "Const Char ptr : "<< strlen(param)<< std::endl; 
} 

template<> void xxx<const std::string & >(const std::string & param) 
{ 
std::cout << "Const String : "<< param.size()<< std::endl; 
} 

template<> void xxx<std::string >(std::string param) 
{ 
std::cout << "String : "<< param.size()<< std::endl; 
} 


int main() 
{ 
     xxx("word"); 
     std::string aword("word"); 
     xxx(aword); 

     std::string const cword("const word"); 
     xxx(cword); 
} 

Aussi template<> void xxx<const std::string & >(const std::string & param) chose ne fonctionne tout simplement pas.

Si je réarrangées le modèle opriginal d'accepter les paramètres comme T& alors le char * doit être char * & qui est pas bon pour le texte statique dans le code.

Aidez s'il vous plaît!

Answer 1

Est-ce que ce qui suit ne fonctionne pas?

template<> 
void xxx<std::string>(std::string& param) 
{ 
    std::cout << "String : "<< param.size()<< std::endl; 
} 

Et la même chose pour const std::string?

Cela dit, don’t specialize a function template si vous avez le choix (et vous le faites habituellement!). Au lieu de cela, juste surcharger la fonction:

void xxx(std::string& param) 
{ 
    std::cout << "String : "<< param.size()<< std::endl; 
} 

avis, c'est pas un modèle. Dans 99% des cas, c'est bien.

(Quelque chose d'autre, C++ n'a pas d'en-tête <string.h> sauf pour rétrocompatibilité C. L'en-tête C-string en C++ est appelé <cstring> (notez le premier c), mais à partir de votre code, il semble que si vous voulez dire réellement . l'en-tête <string> (pas leader c))

Answer 2

Voici une distillation de ce que je trouve surprenant:

#include <iostream> 

template<typename T> void f(T param) { std::cout << "General" << std::endl ; } 
template<> void f(int& param) { std::cout << "int&" << std::endl ; } 

int main() { 
    float x ; f (x) ; 
    int y ; f (y) ; 
    int& z = y ; f (z) ; 
} 

Cette impression "général" 3 fois. La première fois (float) est attendue, la troisième fois (int &) est une surprise. Pourquoi ça ne marche pas?

Answer 3

est vraiment essayer risqué de codage utilisant des conversions de type-base compilateur

une chose est l'utilisation d'un modèle basé, et d'autres est l'utilisation de polymorphes avec différents types. En fonction du compilateur, vous pouvez obtenir différents comportements.