Discussion :

[randomlyGenerated]

Bonjour,

j'aurais voulu surcharger certains operateur de la class string. Je pense avoir un embrayon de solution mais qui hélas ne fonctionne qu'a moitié.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
namespace std
{
	template<typename T>
	string operator+(const string &s,const T &t)
	{
		string tmp = s;
		ostringstream oss;
    	oss << t;
		tmp.append(oss.str());
    	return tmp;		
	}
	template<typename T>
	string & operator+= (string & s,const T &t)		
	{													
		return (s = s + t);				
	}
 
	template<typename T>
	string & operator<< (string & s,const T &t)		
	{													
		return (s = s + t);				
	}
}

Ce code fonctionne très bien, exepté pour les types déjà surchargé... existe il une solution pour palier à ce problème?

Merci d'avance pour votre réponse

[JolyLoic]

La surcharge d'opérateurs ne fonctionne que si l'un des arguments est de type défini par l'utilisateur.

Ton problème n'est pas soluble à ma connaissance.

[Jean-Marc.Bourguet]

La surcharge d'opérateurs ne fonctionne que si l'un des arguments est de type défini par l'utilisateur.

Est-ce que c'est moi qui suis mal réveillé et que l'évident m'échappe. std::string en est un.

Ton problème n'est pas soluble à ma connaissance.

Je ne suis pas sûr de comprendre quel est son problème. J'aimerais un exemple.

- Il n'a pas le droit de définir des choses dans le namespace std; mais je doute que ça pose un problème pratique.

- Une fonction normale surchargée avec une fonction template a priorité sur ce dernier. Je me demande, mais je ne suis pas sur, si ce n'est pas la cause de son problème.

[randomlyGenerated]

j'aurais voulu etendre la classe string de la stl pour pouvoir ecrire des choses du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
std::string s;
s = "test";
s += 5; //contenu de s: test5

[loufoque]

Quelle erreur as-tu exactement avec ton code ?

Accessoirement tu ferais mieux de coder operator+ avec operator+= et pas l'inverse.

[Alp]

Sinon, dans le pire des cas, tu wrap std::string dans une autre classe, avec tes opérateurs à toi définis dans cette classe, se servant de ceux de std::string.

[JolyLoic]

Est-ce que c'est moi qui suis mal réveillé et que l'évident m'échappe. std::string en est un.

Non, non, c'était moi... J'ai cru qu'il fallait qu'un paramètre soit un type défini par l'utilisateur, alors que ce qui est dans std:: est défini dans le standard. La vraie règle est que l'un des arguments doit être une classe, une énumération, ou une référence à une classe ou une énumération. Merci d'avoir rectifié.

- Une fonction normale surchargée avec une fonction template a priorité sur ce dernier. Je me demande, mais je ne suis pas sur, si ce n'est pas la cause de son problème.

Effectivement, ça me semble plausible. Ou autre hypothèse : La fonction suivante est déjà définie, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs);

Donc, dans ce cas, s'il écrit string("Tot") + 'o' il devra y avoir résolution de surcharge entre la fonction du standard et sa fonction. Mon "C++ Template, the complete guide" étant au boulot, et n'ayant pas le courage de relire la partie correspondante de la norme, je risque de dire une (autre) bêtise.

Il me semble que dans ce cas, ce qui compte est de savoir des deux fonctions template est la "plus spécialisée". Dans ce cas toujours, je crois il n'y a pas moyen de les départager selon ce critère d'ordre partiel, et donc que l'appel de fonction est ambigu.

Maintenant, si son opérateur était lui aussi templatisé en fonction du type de chaîne, alors la fonction du standard qui explicite l'utilisation de char serait préférée à la sienne qui spécifie le type char par argument template, et ça lèverait l'ambiguïté.

[randomlyGenerated]

- Il n'a pas le droit de définir des choses dans le namespace std; mais je doute que ça pose un problème pratique.

Pourquoi?

Quelle erreur as-tu exactement avec ton code ?

Ca fonctionne bien tant que je n'utilise pas un des operateurs pour un type déjà défini dans la stl. Le compilateur de pouvant départager les deux fonctions.

Accessoirement tu ferais mieux de coder operator+ avec operator+= et pas l'inverse.

Pourquoi?

Sinon, dans le pire des cas, tu wrap std::string dans une autre classe, avec tes opérateurs à toi définis dans cette classe, se servant de ceux de std::string.

J'aurais voulu pouvoir continuer à utiliser std::string et pouvoir redéfinir les operateurs de manière générique pour tous les types...

Maintenant, si son opérateur était lui aussi templatisé en fonction du type de chaîne, alors la fonction du standard qui explicite l'utilisation de char serait préférée à la sienne qui spécifie le type char par argument template, et ça lèverait l'ambiguïté.

Je comprend pas bien ce que tu veux dire...


Merci pour vos réponses

[loufoque]

Pour éviter de passer par une variable temporaire.

[JolyLoic]

Je comprend pas bien ce que tu veux dire...

Je veux dire (encore une fois, je parle sans mes références sous le coude) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int f (int i, int j); //1
template <class T> int f(T i, int j); //2
template <class T> int f(int i, T j); //3
template <class T, class U> int f(T i, U j); //4
 
int a, b;
f(a,b);

Si on a défini 1 et 2, ou 1 et 3, l'appel de fonction appèlera 1, une fonction non template ayant priorité sur une template. Si on a défini 2 et 3, il y a ambiguïté, les deux fonction étant aussi bonnes. C'est ton cas actuellement. Par contre, si on défini 2 et 4 ou 3 et 4, il me semble que dans ce cas là, 4, qui est plus templatés que 2 ou 3, auras moins la priorité, et c'est l'autre qui sera choisie.

Dans ton cas, en templatant aussi en fonction du type de chaîne, tu transforme ta fonction de catégorie 3 en fonction de catégorie 4, sachant que le standard en a fourni une de catégorie 2.

Si ça ne marche pas, ou si tu veux que ce soit une fonction à toi qui soit retenue, et non celle du standard, tu peux aussi définir une fonction de catégorie 1 pour chacun des types qui posent problème (char, char* et string, je crois).

[randomlyGenerated]

Merci pour ta proposition mais ça fonctionne pas bien. J'ai des conflis entre les différentes signatures de fonctions.

J vais tenter de m'en sortir autrement, ça me semble un peu trop hasardeux de vouloir redéfinir des choses dans le namespace std...