Surcharge d’opérateur

2024-07-15

Le mot clé operator déclare une fonction spécifiant la signification de symbole-opérateur quand il est appliqué aux instances d’une classe. Cela donne à l'opérateur plusieurs significations ou le « surcharge ». Le compilateur fait la distinction entre les différentes significations d’un opérateur en examinant les types de ses opérandes.

Syntaxe

type operator symbole-opérateur ( liste-paramètres )

Notes

Vous pouvez redéfinir la fonction de la plupart des opérateurs intégrés de manière globale ou classe par classe. Les opérateurs surchargés sont implémentés en tant que fonctions.

Le nom d’un opérateur surchargé est operator x, où x est l’opérateur tel qu’il apparaît dans le tableau suivant. Par exemple, pour surcharger l’opérateur d’addition, vous définissez une fonction appelée operator+. De la même façon, pour surcharger l’opérateur d’addition/affectation, +=, vous définissez une fonction appelée operator+=.

Opérateurs redéfinissables

Opérateur	Nom	Type
,	Virgule	Binary
!	NOT logique	Unaire
!=	Inégalité	Binary
%	Modulo	Binary
%=	Assignation de modulo	Binary
&	ET au niveau du bit	Binary
&	Adresse-de	Unaire
&&	ET logique	Binary
&=	Assignation d'opération AND au niveau du bit	Binary
( )	Appel de fonction	—
( )	Opérateur de conversion	Unaire
*``**	Multiplication	Binary
*``**	Déréférencement du pointeur	Unaire
*`=`**	Assignation de multiplication	Binary
+	Addition	Binary
+	Plus unaire	Unaire
++	Incrément ¹	Unaire
+=	Assignation d'addition	Binary
-	Soustraction	Binary
-	Négation unaire	Unaire
--	Décrément ¹	Unaire
-=	Assignation de soustraction	Binary
->	Sélection de membres	Binary
*`->`**	Sélection de pointeur de membre	Binary
/	Division	Binary
/=	Assignation de division	Binary
<	Inférieur à	Binary
<<	Décalage vers la gauche	Binary
<<=	Assignation de décalage vers la gauche	Binary
<=	Inférieur ou égal à	Binary
=	Affectation	Binary
==	Égalité	Binary
>	Supérieur(e) à	Binary
>=	Supérieur ou égal à	Binary
>>	Décalage vers la droite	Binary
>>=	Assignation de décalage vers la droite	Binary
[ ]	Indice de tableau	—
^	OR exclusive	Binary
^=	Assignation OR exclusive	Binary
\|	Opération OR inclusive au niveau du bit	Binary
\|=	Assignation d'opération OR inclusive au niveau du bit	Binary
\|\|	OU logique	Binary
~	Complément à 1	Unaire
`delete`	Supprimer	—
`new`	Nouvelle	—
opérateurs de conversion	opérateurs de conversion	Unaire

¹ Il existe deux versions des opérateurs d’incrémentation et de décrémentation unaire : préincrément et postincrément.

Pour plus d’informations, consultez Règles générales pour la surcharge des opérateurs. Les contraintes sur les différentes catégories d'opérateurs surchargés sont décrites dans les rubriques suivantes :

Les opérateurs indiqués dans le tableau suivant ne peuvent pas être surchargés. Le tableau inclut les symboles de préprocesseur # et ##.

Opérateurs non redéfinissables

Opérateur	Nom
.	Sélection de membres
*`.`**	Sélection de pointeur de membre
::	Résolution de portée
? :	Conditions
#	Préprocesseur convertir en type string
##	Préprocesseur concaténer

Bien que les opérateurs surchargés soient généralement appelés implicitement par le compilateur quand ils sont trouvés dans le code, ils peuvent être invoqués explicitement de la même façon que n'importe quelle fonction membre ou non membre :

Point pt;
pt.operator+( 3 );  // Call addition operator to add 3 to pt.

Exemple

L’exemple suivant surcharge l’opérateur + pour additionner deux nombres complexes et retourne le résultat.

// operator_overloading.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

struct Complex {
   Complex( double r, double i ) : re(r), im(i) {}
   Complex operator+( Complex &other );
   void Display( ) {   cout << re << ", " << im << endl; }
private:
   double re, im;
};

// Operator overloaded using a member function
Complex Complex::operator+( Complex &other ) {
   return Complex( re + other.re, im + other.im );
}

int main() {
   Complex a = Complex( 1.2, 3.4 );
   Complex b = Complex( 5.6, 7.8 );
   Complex c = Complex( 0.0, 0.0 );

   c = a + b;
   c.Display();
}

6.8, 11.2

Contenu de cette section

Voir aussi

Opérateurs intégrés, priorité et associativité C++
Mots clés

Partager via