Utilisation de spécialisation de template pour convertir.

Bonjour,

Est-il possible de créer un template via spécialisation permettant
de convertir des types définit (bool, int, string, ...) vers un
std::string ?

template<class T>
std::string TranslateToString(const T& value)
{
std::stringstream s;
s << value;
return s.str();
}

Pour que ca marche, il faut qu'il y ait un opérateur ostream << T (il y a
ca pour tous les types de bases, et tu devras le définir si tu veux
traduire des classes à toi)

Bonjour,

Est-il possible de créer un template via spécialisation permettant
de convertir des types définit (bool, int, string, ...) vers un
std::string ?

Je m'explique.

J'essaie de créer une classe permettant de lire des settings provenant
d'un fichier de conf.

Donc, dedans, j'ai créé une méthode générique, du style :

class Settings {
private:
typedef std::map <std::string, std::string> MapSettings;
MapSettings mSettings;
public:
template <class T> const T& Read (const std::string& pVariable,
const T& pDefaultValue) {
/**
* Si variable présente dans la map on retourne la valeur
* trouvée, sinon, on retourne la valeur par défaut.
* On rajoute tout de même pDefaultValue dans map pour une
prochaine * utilisation.
*/

mSettings[pVariable] = TranslateToString (pDefaultValue);

return pDefaultValue;
}
};

Ce que j'aimerais c'est que TranslateToString prenne ma valeur et la
transforme directement en chaine de caractère.
Pour cela, j'avais pensé à un template sur une fonction ou sur une
méthode, mais cela ne semble pas fonctionner correctement.

Voir mon post
précédent.

Mais sinon, j'avais pensé à ceci.

dans ma classe Settings, il y aurait la méthode TranslateToString définie
comme suit :
class Settings {
private:
...
public:
...
template <class T> std::string TranslateToString (const T& pValue)
{ }
template <> std::string TranslateToString <bool> (const bool&
pValue) {
return (pValue ? "True" : "False");
}
template <> std::string TranslateToString <int> (const int&
pValue) {
return "Chaine de test...";
}
};

template<typename T> std::string TranslateToString(T const & value) {
std::stringstream o;
o << value;
return o.str();
}
Effectivement, c'est ce que Vincent m'avait proposé hier soir, et que j'ai appliqué.

DsSettings::Read est utilisée de la manière suivante :

DsSettings& mSettings = DsSettings::GetInstance();
int smtpPort = mSettings.Read ("Port", 25);
int hostname = mSettings.Read ("Hostname", "localhost");

Donc, tout comme la fonction TranslateToString qui me permettait de
transformer le type des valeurs vers des std::string, j'aimerais savoir si
il est possible de transformer mes std::string vers les types employés
lors de l'appel de ma méthode template ?

string hostname = mSettings.Read ("Hostname", "localhost");
(je suppose que c'est string hostname, pas int hostname comme dans le

Donc, tout comme la fonction TranslateToString qui me permettait de
transformer le type des valeurs vers des std::string, j'aimerais savoir
si il est possible de transformer mes std::string vers les types employés
lors de l'appel de ma méthode template ?

euh, mais c'est ce que fait la fonction stringTo, où est le problème ?
Le voici le problème :

Juste un détail à propos du code ici :

string hostname = mSettings.Read ("Hostname", "localhost");
(je suppose que c'est string hostname, pas int hostname comme dans le

message..)
Effectivement, il s'agit bien de string hostname, j'ai fais une ptite

utiliser la valeur par défaut pour en déduire le type voulu marche dans le
cas général, mais là le type ne sera pas string (plutot const char[9], ou
char * ..).
il faudrait expliciter le parametre template :

string hostname = mSettings.Read<string> ("Hostname", "localhost");
Je ne veux utiliser un template de manière explicite, j'aimerais que cela

(et en passant, on pourrait spécialiser stringTo pour T=string :
template <> const std::string&
StringTo<std::string> (const std::string& pValue) {
return pValue;
}

ça éviterait de construire un stringstream inutilement pour lire un
string ...
Je suis tout à fait d'accord avec toi.

c'est le genre de détails que boost::lexical_cast gère probablement
directement)
J'essaie de faire cela sans boost, afin d'apprendre.

DsSettings.hpp: In member function `const T&
DsSante::DsSettings::Read(const
std::string&, const T&) [with T = int]':
DsSante.cpp:25: instantiated from here
DsSettings.hpp:51: error: no matching function for call to `StringTo(
std::basic_string<char, std::char_traits<char>, std::allocator<char>

&)'

string hostname = mSettings.Read<string> ("Hostname", "localhost");
Je ne veux utiliser un template de manière explicite, j'aimerais que cela

soit implicite, ce qui me permettra de créer du code bien plus dynamique.

3. spécialiser Read pour T=const char* pour éviter le problème
-> duplique inutilement du code. enfin, du coup on peut carrément éviter
l'appel à stringTo dans ce Read<const char*> spécialisé..

Samuel Krempp <krempp@crans.truc.en.trop.ens-cachan.fr> writes:

3. spécialiser Read pour T=const char* pour éviter le problème
-> duplique inutilement du code. enfin, du coup on peut carrément éviter
l'appel à stringTo dans ce Read<const char*> spécialisé..

Qu'est-ce que ça change? La spécialisation sur char
const[9] sera meilleure et générée si besoin est. Une
surchage du genre
template <int N>
void Read(std::string const&, char const (&p) [N]);