Aucune conversion implicite dans l'opérateur surchargée
-
09-10-2019 - |
Question
d1 + 4
fonctionne mais ne 4 + d1
même pas si 4 peut être converti implicitement à un GMan. Pourquoi ne sont-ils équivalents?
struct GMan
{
int a, b;
GMan() : a(), b() {}
GMan(int _a) : a(_a), b() {}
GMan(int _a, int _b) : a(_a), b(_b) {}
GMan operator +(const GMan& _b)
{
GMan d;
d.a = this->a + _b.a;
d.b = this->b + _b.b;
return d;
}
};
int main()
{
GMan d1(1, 2), d(2);
GMan d3;
d3 = d1 + 4;
d3 = 4 + d1;
}
La solution
par le C ++ du compilateur dans l'une des deux appels suivants (selon que x + y
est de type classe, et si une telle fonction existe) est traduit un x
d'appel:
-
fonction membre
x.operator +(y);
-
Fonction libre
operator +(x, y);
C ++ a une règle simple: pas de conversion implicite peut se produire avant un opérateur d'accès membre (.
). De cette façon, x
dans le code ci-dessus ne peut pas subir une conversion implicite dans le premier code, mais il peut dans le second.
Cette règle est logique: si x
pourrait être converti implicitement dans le premier code ci-dessus, le compilateur C ++ ne connaîtrait pas plus que la fonction d'appel (c.-à quelle classe il appartient) il devrait rechercher toutes les classes existant pour une fonction de membre correspondant. Cela semer la pagaille dans le système de type « C ++ et rendre les règles encore plus complexe la surcharge et la confusion.
Autres conseils
Cette réponse est correcte. Ces points impliquent alors la manière canonique de mettre en œuvre ces opérateurs:
struct GMan
{
int a, b;
/* Side-note: these could be combined:
GMan():a(),b(){}
GMan(int _a):a(_a),b(){}
GMan(int _a, int _b):a(_a),b(_b){}
*/
GMan(int _a = 0, int _b = 0) : a(_a), b(_b){} // into this
// first implement the mutating operator
GMan& operator+=(const GMan& _b)
{
// the use of 'this' to access members
// is generally seen as noise
a += _b.a;
b += _b.b;
return *this;
}
};
// then use it to implement the non-mutating operator, as a free-function
// (always prefer free-functions over member-functions, for various reasons)
GMan operator+(GMan _a, const GMan& _b)
{
_a += b; // code re-use
return _a;
}
Et ainsi de suite pour les autres opérateurs.