Surcharge des opérateurs arithmétiques

Question

L'opérateur d'affectation peut être déclaré comme

T& operator= (const t&) ;

dans une classe, mais les opérateurs arithmétiques ne peuvent pas être définis de cette façon. Il faut que ce soit une fonction amie. Je ne comprends pas pourquoi ? Pouvez-vous m'expliquer ?

Answer 1

Il n'est pas obligatoire que les opérateurs arithmétiques soient des amis.

On peut le définir comme ça :

MyClass MyClass::operator + (const MyClass& t) const
{
  MyClass ret(*this);
  ret += t;
  return ret;
}

El a + b est en fait un sucre de syntaxe, le compilateur le développera en a.operator+(b) . L'exemple précédent fonctionnera si tous vos objets sont des instances de MyClass, mais ne fonctionnera pas si vous devez opérer avec d'autres types, c'est-à-dire 1 + a ne fonctionnera pas, ce problème peut être résolu en utilisant des amis.

MyClass operator + (int i, const MyClass& t)
{
  MyClass ret(i);
  ret += t;
  return ret;
}

Cela doit être fait lorsque le côté gauche de l'opérateur + n'est pas une classe, ou qu'il s'agit d'une classe mais que vous ne pouvez pas ajouter l'opérateur + à sa définition.

Answer 2

Idéalement, ils devraient être des globaux et pas nécessairement des amis, afin que vous puissiez écrire :

yourtype v = 1;
yourtype w = 1 + v;

Puisque, 1 n'est pas un objet de yourtype si le operator+ était un membre, il ferait une crise. Cependant, en le rendant global, il convertit le 1 en yourtype puis effectuez l'opération. En faire un ami permet d'extraire et de manipuler les membres de yourtype comme requis - bien que non requis. À titre d'exemple : Vous pouvez implémenter la fonction membre operator+= et l'utiliser dans l'implémentation de la operator+ .

Answer 3

Je pense que FAQ C++ Lite vous donnera une réponse définitive.

Answer 4

Le problème est que si vous faites quelque chose comme ça :

class A
{
    A& operator+(int n);
    // ...
}

int main()
{
    A my_var;
    int integer = 1;
    A + integer; // compiles
    integer + A // error: no function operator+(int, A) defined
}

il ne compilera pas. Une solution est de définir operator+(int, A) et operator+(A, int) comme amis de A. À titre d'information, la bibliothèque Boost Operators rend ce processus très facile.