Surcharge d'opérateur C ++ (avec exemples)

Dans ce didacticiel, nous allons découvrir la surcharge des opérateurs à l'aide d'exemples.

En C ++, nous pouvons changer la façon dont les opérateurs fonctionnent pour les types définis par l'utilisateur comme les objets et les structures. C'est ce qu'on appelle la surcharge de l'opérateur . Par exemple,

Supposons que nous ayons créé trois objets c1, c2 et résultent d'une classe nommée Complexqui représente des nombres complexes.

Étant donné que la surcharge d'opérateurs nous permet de modifier le fonctionnement des opérateurs, nous pouvons redéfinir le fonctionnement de l' +opérateur et l'utiliser pour ajouter les nombres complexes de c1 et c2 en écrivant le code suivant:

 result = c1 + c2;

au lieu de quelque chose comme

 result = c1.addNumbers(c2);

Cela rend notre code intuitif et facile à comprendre.

Note: Nous ne pouvons pas utiliser la surcharge d' opérateur pour les types de données fondamentales comme int, float, charet ainsi de suite.

Syntaxe pour la surcharge d'opérateurs C ++

Pour surcharger un opérateur, nous utilisons une operatorfonction spéciale .

 class className (… public returnType operator symbol (arguments) (… )… );

Ici,

  • returnType est le type de retour de la fonction.
  • opérateur est un mot-clé.
  • symbolest l'opérateur que nous voulons surcharger. Comme: +, <, -, ++, etc.
  • arguments sont les arguments passés à la fonction.

Surcharge des opérateurs dans les opérateurs unaires

Les opérateurs unaires n'opèrent que sur un seul opérande. L'opérateur d'incrémentation ++et l' opérateur de décrémentation --sont des exemples d'opérateurs unaires.

Exemple 1: surcharge de l'opérateur ++ (opérateur unaire)

 // Overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ ()" function ++count1; count1.display(); return 0; )

Production

 Nombre: 6

Ici, lorsque nous utilisons ++count1;, le void operator ++ ()est appelé. Cela augmente de 1 l'attribut value pour l'objet count1.

Remarque: lorsque nous surchargons des opérateurs, nous pouvons l'utiliser pour travailler comme nous le souhaitons. Par exemple, nous aurions pu ++augmenter la valeur de 100.

Cependant, cela rend notre code confus et difficile à comprendre. C'est notre travail en tant que programmeur d'utiliser la surcharge d'opérateurs correctement et de manière cohérente et intuitive.

L'exemple ci-dessus ne fonctionne que lorsqu'il ++est utilisé comme préfixe. Pour faire ++fonctionner un postfix, nous utilisons cette syntaxe.

 void operator ++ (int) ( // code )

Remarquez l' intintérieur des parenthèses. C'est la syntaxe utilisée pour utiliser des opérateurs unaires comme suffixe; ce n'est pas un paramètre de fonction.

Exemple 2: surcharge de l'opérateur ++ (opérateur unaire)

 // Overload ++ when used as prefix and postfix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) // Overload ++ when used as postfix void operator ++ (int) ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ (int)" function count1++; count1.display(); // Call the "void operator ++ ()" function ++ count1; count1.display(); return 0; )

Production

 Nombre: 6 Nombre: 7

L' exemple 2 fonctionne quand ++est utilisé à la fois comme préfixe et suffixe. Cependant, cela ne fonctionne pas si nous essayons de faire quelque chose comme ceci:

 Count count1, result; // Error result = ++count1;

C'est parce que le type de retour de notre fonction opérateur est void. Nous pouvons résoudre ce problème en faisant Countcomme type de retour de la fonction opérateur.

 // return Count when ++ used as prefix Count operator ++ () ( // code ) // return Count when ++ used as postfix Count operator ++ (int) ( // code )

Exemple 3: valeur de retour de la fonction opérateur (opérateur ++)

 #include using namespace std; class Count ( private: int value; public : // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) // Overload ++ when used as postfix Count operator ++ (int) ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1, result; // Call the "Count operator ++ ()" function result = ++count1; result.display(); // Call the "Count operator ++ (int)" function result = count1++; result.display(); return 0; )

Production

 Nombre: 6 Nombre: 7

Ici, nous avons utilisé le code suivant pour la surcharge des opérateurs de préfixe:

 // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; )

Le code de la surcharge de l'opérateur postfix est également le même. Notez que nous avons créé un objet temp et renvoyé sa valeur à la fonction opérateur.

Notez également le code

 temp.value = ++value;

La valeur de la variable appartient à l'objet count1 dans main()car count1 appelle la fonction, tandis que temp.value appartient à l'objet temp.

Surcharge des opérateurs dans les opérateurs binaires

Les opérateurs binaires fonctionnent sur deux opérandes. Par exemple,

 result = num + 9;

Voici +un opérateur binaire qui fonctionne sur les opérandes num et 9.

Lorsque nous surchargons l'opérateur binaire pour les types définis par l'utilisateur à l'aide du code:

 obj3 = obj1 + obj2;

La fonction opérateur est appelée à l'aide de l'objet obj1 et obj2 est passé comme argument à la fonction.

Exemple 4: surcharge d'opérateur binaire C ++

 // C++ program to overload the binary operator + // This program adds two complex numbers #include using namespace std; class Complex ( private: float real; float imag; public: // Constructor to initialize real and imag to 0 Complex() : real(0), imag(0) () void input() ( cout <> real; cin>> imag; ) // Overload the + operator Complex operator + (const Complex& obj) ( Complex temp; temp.real = real + obj.real; temp.imag = imag + obj.imag; return temp; ) void output() ( if (imag < 0) cout << "Output Complex number: " << real << imag << "i"; else cout << "Output Complex number: " << real << "+" << imag << "i"; ) ); int main() ( Complex complex1, complex2, result; cout << "Enter first complex number:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Production

 Entrez le premier nombre complexe: Entrez respectivement les parties réelles et imaginaires: 9 5 Entrez le deuxième nombre complexe: Entrez les parties réelles et imaginaires respectivement: 7 6 Sortie Nombre complexe: 16 + 11i

Dans ce programme, la fonction opérateur est:

 Complex operator + (const Complex& obj) ( // code )

Au lieu de cela, nous aurions également pu écrire cette fonction comme:

 Complex operator + (Complex obj) ( // code )

cependant,

  • using &rend notre code efficace en référençant l'objet complex2 au lieu de créer un objet dupliqué dans la fonction opérateur.
  • l'utilisation constest considérée comme une bonne pratique car elle empêche la fonction opérateur de modifier complex2.
Surcharge des opérateurs binaires en C ++

Points à retenir lors de la surcharge d'opérateurs C ++

  1. Deux opérateurs =et &sont déjà surchargés par défaut en C ++. Par exemple, pour copier des objets de la même classe, nous pouvons directement utiliser l' =opérateur. Nous n'avons pas besoin de créer une fonction d'opérateur.
  2. La surcharge des opérateurs ne peut pas modifier la priorité et l'associativité des opérateurs. Cependant, si nous voulons changer l'ordre d'évaluation, les parenthèses doivent être utilisées.
  3. Il existe 4 opérateurs qui ne peuvent pas être surchargés en C ++. Elles sont:
    1. :: (résolution de la portée)
    2. . (sélection des membres)
    3. .* (sélection de membres via le pointeur vers la fonction)
    4. ?: (opérateur ternaire)

Visitez ces pages pour en savoir plus sur:

  • Comment surcharger l'opérateur d'incrémentation de la bonne manière?
  • Comment surcharger l'opérateur binaire - pour soustraire des nombres complexes?

Articles intéressants...