Existe-t-il une fonction de modèle sans avertissement pour convertir les types de base en chaîne

Question

Je souhaite fournir une fonction de modèle qui convertit la plupart des types de base en chaîne. Le meilleur que je suis venu avec à ce jour est la suivante:

template<typename T> inline std::string anyToString(const T& var) { 
    std::ostringstream o; 
    o << var; 
    return o.str(); 
} 

La fonction peut par exemple être utilisé pour les éléments suivants:

class TimeError:public std::runtime_error{ 
    public: 
     explicit TimeError(int time):std::runtime_error(anyToString(time)), 
     mTime(time){}; 
    protected: 
     int mTime; 
    }; 

Le problème avec anyToString et des fonctions similaires est la génération d'avertissements d'ambiguïté lors de la compilation avec gcc version 4.4.3 -Wall -Wexta -Werror "ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second "

A ma connaissance la raison de l'avertissement réside dans les possibilités de conversion implicite lors de l'appel < <

Ces ambiguïtés sont principalement générées par d'autres modèles comme suit:.

template<typename T> 
    T& operator<<(T& out, const SymRad& angle){ 
    return out << angle.deg(); 
    } 

Mais ceux-ci ont d'autres avantages comme travailler pour plusieurs types de flux. Alors j'aimerais les garder. Si je transforme le deuxième modèle en une méthode simple, par ex. ostream l'ambiguïté est nettoyée, mais je cherche sth. Cela permet de garder les deux modèles. Existe-t-il une fonction générique qui offre la même simplicité sans générer d'avertissement à l'aide des options décrites? Si non, quelle est la meilleure façon de localement désactiver l'avertissement émis?

Answer 1

Il semble que vous obtiendrez un message d'un scénario comme celui-ci:

#include <sstream> 
#include <string> 
#include <iostream> 

struct Y {}; 
struct X 
{ 
    operator Y() const {return Y(); } 
}; 

std::ostream& operator<< (std::ostream& os, X) { return os << "X"; } 
std::ostream& operator<< (std::ostringstream& os, Y) { return os << "Y"; } 

template<typename T> inline std::string anyToString(const T& var) { 
    std::ostringstream o; 
    o << var; 
    return o.str(); 
} 

int main() 
{ 
    std::cout << anyToString(X()) << '\n'; 
} 

Je vous recommande d'utiliser le drapeau -pedantic à la place. GCC le compile du tout grâce à une extension de compilateur, avec d'autres compilateurs ce sera une erreur directe.

---

Quant à votre ajout:

template<typename T> 
    T& operator<<(T& out, const SymRad& angle){ 
    return out << angle.deg(); 
    } 

Mais ceux-ci ont d'autres avantages comme travailler pour plusieurs types de flux.

Ceci ne fonctionne pas pour plusieurs types de flux. Par exemple si T est stringstream, alors out << angle.deg(); renverra probablement une référence à un ostream qui ne peut être implicitement rétrogradé à une référence stringstream.

Answer 2

Votre compilateur supporte un #pragma dans ce but, autant que je sache - je sais que VC++ le fait. Cependant, vous pouvez simplement utiliser boost :: lexical_cast, aussi.