overloading ou spécialisation... telle est la question

11 réponses

11/03/2010 à 12:11

Bonjour,

Voici ma fonction template:

template <class C>
string ReadFile::ValToString(C in)
{
ostringstream i;
i << in;
return i.str();
}

Mais pour les classes de types string, cette fonction ne fonctionne
pas pour plusieurs raisons:
l'op=E9rateur << s'arr=EAte au premier espace. En plus de cela je voudrais
rajouter des guillemets.

Donc j'ai fait une specialisation (?)

template<>
string ReadFile::ValToString(string in)
{
return "\"" + in + "\"";
}

qui a l'air de marcher.

Pour les classes de types C=3Dvector<T> ou m=EAme C=3Dvector<vector<T> > je
voudrais rajouter des parenth=E8ses. Donc j'ai fait:

template <>
string ReadFile::ValToString<vector<T> >(vector<T> in)
{
ostringstream i;
i << in;
return "(" + i.str() + ")";
}

cette derni=E8re fonction n'est bien s=FBr jamais appel=E9e. C'est la
fonction plus g=E9n=E9rale qui est appel=E9e =E0 la place. Est-ce qu'il exi=
ste
un moyen de contourner ce probl=E8me ? Je tourne sous visual.

Alexandre.

PS: j'oublierais pas de rajouter les const l=E0 ou il faut, promis :-)

1 réponse

1 2

12/03/2010 à 14:44

On Mar 12, 2:10 pm, Jean-Marc Bourguet wrote:

Tu peux ne pas mettre de <> du tout: ValToString(v)

mais pour faire ce que tu veux, ce n'est plus de la surcharge mais de la
specialisation partielle qu'il faut et ce n'est possible qu'avec les
classes. Donc il faut faire intervenir une classe, par exemple dans
l'implementation de ValToString qui peut donc ne plus etre surchargee.

Hé hé, en parallèle j'en était presque arrivé à la même solut ion.
Merci !

#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <functional>

using namespace std;

template<class C> ostream & operator<<(ostream &o, vector<C> v);

template <class T> class A
{
public:
static string apply(T & in){ ostringstream buff; buff << in; return
buff.str();}
};

template<class T> class A<vector<T> >
{
public:
static string apply(vector<T> & in) { ostringstream buff; buff << in;
return "(" + buff.str() + ")";}
};

template<class T> string ValToString(T & in)
{
return A<T>::apply(in);
}

int main(int argc, char * argv[])
{
int i=3;
vector<int> v;
v.push_back(1);
v.push_back(3);
v.push_back(4);
cout << "3 -> " << ValToString(i) << "n";
cout << "{1,3,4} -> " << ValToString(v) << "n";
}

template<class C>
ostream & operator<<(ostream &o, vector<C> v)
{
vector<C>::iterator i;
for(i=v.begin();i!=v.end();++i)
{
o << *i << " ";
}
return o;
}

1 2

overloading ou spécialisation... telle est la question

1 réponse

Veuillez sélectionner un problème