« spécialisation Ambiguous modèle » problème

Question

Je portage actuellement un tas de code qui a déjà été seulement compilé avec Visual Studio 2008. Dans ce code, il y a un arrangement comme celui-ci:

En général, il sont beaucoup de spécialisations de la fonction ayant différents types de retour qui sont invoqués comme ceci:

int i = convert<int>(szInt); 

le problème est que ces spécialisations de modèle se traduisent par « spécialisation Ambiguous modèle ». Si c'était quelque chose en plus du type de retour qui différenciait ces spécialisations de fonction, je pourrais bien évidemment utiliser des surcharges, mais ce n'est pas une option.

Comment résoudre ceci sans avoir à changer tous les endroits où les fonctions de conversion sont appelées?

Mise à jour j'ajouté ces deux fourre-tout spécialisations de modèle que j'omis la première fois. Je suis gêné de dire, je ne suis pas sûr de la motivation pour le second, mais le premier est dû à la fonction de conversion étant utilisé beaucoup d'endroits où les données de chaîne est passé comme un vide *. Je ne suis pas en mesure de vérifier avec GCC en ce moment, mais je soupçonne que ceux-ci pourraient être le problème.

Update 2 Voici le fichier cpp complet qui reproduit cela. Si vous supprimez les deux fonctions "générales", elles seront compilées. Si vous laissez l'un d'entre eux rester, l'erreur de spécialisation de modèle ambigu sera générée.

#include <iostream> 
#include <sstream> 

template <typename T> 
T convert(const char * s) 
{ 
    // this is a slow slow general purpose catch all, if no specialization is provided 
    std::istringstream is(s); 
    T ret; 
    is >> ret; 
    return ret; 
} 

// general purpose 1 
template <typename T, typename T2> 
T convert(T2 * s) 
{ 
    return convert<T>(static_cast<const char*>(s)); 
} 

// general purpose 2 
template <typename T, typename T2> 
T convert(T2 s) 
{ 
    return T(s); 
} 

// Type specialized 

template <> 
inline float convert<float>(const char * s) 
{ 
    return (float)atof(s); 
} 

int main(int argc, const char * sz[]) 
{ 
    return 0; 
} 

Answer 1

Apparemment return convert<T>(static_cast<const char*>(s)); (ou quelque chose d'autre, je ne vois pas) est le compilateur pour induire créer un instanciation de modèle de T convert(const char * s) T = float. Ensuite, lorsque vous essayez de le spécialiser plus tard, il échoue car la version du modèle existe déjà.

Lorsque j'ai déplacé le inline float convert<float>(const char * s) avant les convertisseurs d'usage général (immédiatement après la fonction modèle const char*), j'ai pu compiler avec succès avec g ++ 4.2.