L'ambiguïté de surcharge d'addition C++

Question

Je rencontre une énigme épineuse dans mon code de base. Je ne peux pas vraiment dire pourquoi mon code génère cette erreur, mais (par exemple) std :: string ne le fait pas.

class String { 
public: 
    String(const char*str); 
    friend String operator+ (const String& lval, const char *rval); 
    friend String operator+ (const char *lval, const String& rval); 
    String operator+ (const String& rval); 
}; 

La mise en œuvre de ceux-ci est assez facile à imaginer par vous-même.

Mon programme pilote contient les éléments suivants:

String result, lval("left side "), rval("of string"); 
char lv[] = "right side ", rv[] = "of string"; 
result = lv + rval; 
printf(result); 
result = (lval + rv); 
printf(result); 

qui génère l'erreur suivante dans gcc 4.1.2:

driver.cpp:25: error: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second: 
String.h:22: note: candidate 1: String operator+(const String&, const char*) 
String.h:24: note: candidate 2: String String::operator+(const String&) 

So far so good, non? Malheureusement, mon constructeur String (const char * str) est si pratique à avoir en tant que constructeur implicite, que l'utilisation du mot-clé explicite pour résoudre cela provoquerait simplement une pile différente de problèmes.

De plus ... std :: string n'a pas à recourir à cela, et je n'arrive pas à comprendre pourquoi. Par exemple, dans basic_string.h, ils sont déclarés comme suit:

template<typename _CharT, typename _Traits, typename _Alloc> 
basic_string<_CharT, _Traits, _Alloc> 
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, 
      const basic_string<_CharT, _Traits, _Alloc>& __rhs) 

template<typename _CharT, typename _Traits, typename _Alloc> 
basic_string<_CharT,_Traits,_Alloc> 
operator+(const _CharT* __lhs, 
      const basic_string<_CharT,_Traits,_Alloc>& __rhs); 

et ainsi de suite. Le constructeur basic_string n'est pas déclaré explicite. Comment cela ne provoque pas la même erreur que moi, et comment puis-je obtenir le même comportement?

Answer 1

La raison de l'ambiguïté est qu'une fonction candidate est meilleure qu'une autre fonction candidate seulement si aucun de ses paramètres sont une plus mauvaise correspondance que les paramètres de l'autre. Tenez compte de vos deux fonctions:

friend String operator+(const String&, const char*); // (a) 
String operator+(const String&);      // (b) 

Vous appelez operator+ avec un String et un const char*.

Le deuxième argument, de type const char*, correspond clairement à (a) mieux qu'à (b). C'est une correspondance exacte pour (a), mais une conversion définie par l'utilisateur est requise pour (b). Par conséquent, pour qu'il y ait ambiguïté, le premier argument doit correspondre à (b) mieux qu'à (a). Le String sur le côté gauche de l'appel à operator+ n'est pas const. Par conséquent, il correspond (b), qui est une fonction membre non-const, mieux que (a), qui prend un const String&.

Par conséquent, l'une des solutions suivantes lèverait l'ambiguïté:

• Modifier le membre operator+ être une fonction membre const
• Modifier le non-membre operator+ de prendre une String& au lieu d'un const String&
• Appel operator+ avec une chaîne const sur le côté gauche

Évidemment, le premier, also suggested by UncleBens, est le meilleur chemin à parcourir.

Answer 2

Il suffit dans ce cas juste pour définir le operator+:

String operator+(const String& lval, const String& rval); 

Parce que vous fournissez un constructeur de prendre un char*, un String peut être construit à partir d'un char* lors de l'appel à operator+. Par exemple:

String hello = "Hello, "; 
const char* world = "world!"; 

String helloWorld = hello + world; 

A String sera construit temporaire avec le contenu du char*world (parce que votre constructeur est pas explicite), puis seront transmis les deux objets String-operator+.

Answer 3

Vous avez montré que basic_string a des implémentations de operator+ correspondant aux deuxième et troisième opérateurs de votre classe String. Est-ce que basic_string a également un opérateur correspondant à votre premier opérateur [friend String operator+ (const String& lval, const char *rval);]? Que se passe-t-il si vous supprimez cet opérateur?

Answer 4

Les fonctions de modèle et hors modèle suivent des règles différentes. Les fonctions du modèle sont sélectionnées sur les types de paramètres réels, sans aucune conversion. Dans le cas du non-modèle (c'est-à-dire votre code), une conversion implicite peut être appliquée. Ainsi, le contenu du template dans basic_string n'est pas ambigu, mais le tien est.

Answer 5

L'erreur disparaît si vous déclarez le membre + const comme il se doit.

class String { 
public: 
    String(const char*str); 
    friend String operator+ (const String& lval, const char *rval); 
    friend String operator+ (const char *lval, const String& rval); 
    String operator+ (const String& rval) const; //<-- here 
}; 

Vous ne savez pas exactement pourquoi. Peut-être préfère-t-il si possible les arguments de liaison à la référence const, donc la première surcharge correspond mieux à la valeur de gauche et la troisième surcharge correspond mieux à la valeur de droite.

Better explanation. (Doit avoir mal interprété le problème un peu.)

---

printf(result); 

Ne me dites pas votre chaîne a la conversion implicite const char* ... C'est le mal.