web-dev-qa-db-fra.com

Surcharge d'opérateur binaire C ++

Selon le programme 9 ++ C++ de Deitel, p. 439-440:

Un opérateur binaire peut être surchargé en tant que fonction membre non statique avec un paramètre ou en tant que fonction non membre avec deux paramètres (l'un de ces paramètres doit être soit un objet classe, soit une référence à un objet classe).

Alors, quel autre type d'objet existe-t-il à côté d'un objet de classe ou d'une référence à un objet de classe? Je n'arrive pas a penser a quoi que ce soit.

c++operator-overloading
8
J. Doe

Alors, quel autre objet y a-t-il à côté de l'objet de classe ou une référence à un objet de classe?

Il existe des types fondamentaux définis par le langage, tels que int, double. Les instances de types fondamentaux sont également des objets.

Disons que vous avez:

struct Foo { ... };

Vous pouvez surcharger le operator+ fonctionne comme des fonctions non membres

Foo operator+(Foo , int);
Foo operator+(Foo& , int);
Foo operator+(int, Foo);
Foo operator+(int, Foo&);

etc. Dans tous ces cas, l'un des arguments est un Foo ou un Foo&. Il peut également s'agir de Foo const&. Cependant, vous ne pouvez pas surcharger

int operator+(int, int);

car aucun des types d'argument n'est une classe ou une référence à une classe.

13
R Sahu

Cela signifie que vous ne pouvez pas (re) définir les opérateurs intégrés comme int operator+(int a, int b);. Notez que la description est incomplète, un ou les deux paramètres peuvent également être un enum.

8
user657267

À l'appui de la réponse de @ user657267,

De over.match.oper/1 :

Si aucun opérande d'un opérateur dans une expression n'a un type qui est une classe ou une énumération , l'opérateur est supposé être un opérateur intégré et interprété selon [expr.compound]

struct String {
  String (const String&);
  String (const char*);
  operator const char* ();
};

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

void f() {
 const char* p = "one" + "two";  // ill-formed because neither operand has class or enumeration type
 int I = 1 + 1;                  // always evaluates to 2 even if class or enumeration types exist
                                 // that would perform the operation.
}

Ainsi, la surcharge operator+ sur les types de données primitifs est mal formé.

4
Joseph D.