Surcharge d'opérateur C ++ avec des exemples

Qu'est-ce que la surcharge de l'opérateur?

En utilisant la surcharge d'opérateurs en C ++, vous pouvez spécifier plusieurs significations pour un opérateur dans une même étendue. Le but de la surcharge d'opérateur est de fournir une signification spéciale d'un opérateur pour un type de données défini par l'utilisateur.

Avec l'aide de la surcharge d'opérateurs, vous pouvez redéfinir la majorité des opérateurs C ++. Vous pouvez également utiliser la surcharge d'opérateur pour effectuer différentes opérations à l'aide d'un seul opérateur.

Dans ce didacticiel C ++, vous apprendrez:

Qu'est-ce que la surcharge de l'opérateur?
Syntaxe
Différentes approches de la surcharge d'opérateurs en C ++
Tous les opérateurs C ++ peuvent-ils être surchargés?
Choses dont il faut se rappeler:
Règles de surcharge des opérateurs:
Comment surcharger l'opérateur:

Syntaxe

Pour surcharger un opérateur C ++, vous devez définir une fonction spéciale à l'intérieur de la classe comme suit:

class class_name{… publicreturn_type operator symbol (argument(s)){… }… };

Voici une explication de la syntaxe ci-dessus:

Return_type est le type de retour de la fonction.
Ensuite, vous mentionnez le mot-clé de l'opérateur.
Le symbole désigne le symbole de l'opérateur à surcharger. Par exemple, +, -, <, ++.
Le ou les arguments peuvent être passés à la fonction opérateur de la même manière que les fonctions.

Exemple 1:

#include using namespace std;class TestClass {private:int count;public:TestClass() : count(5) {}void operator --() {count = count - 3;}void Display() {cout << "Count: " << count; }};int main() {TestClass tc;--tc;tc.Display();return 0;}

Production:

Voici une capture d'écran du code:

Explication du code:

Inclure le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
Créez une classe nommée TestClass.
Utilisez le modificateur d'accès privé, qui marque un membre de classe comme accessible en privé.
Créez un nombre entier de variables. Cette variable sera accessible en privé.
Utilisez le modificateur d'accès public, qui marque un membre de classe comme accessible en privé.
Utilisez un constructeur de classe pour initialiser le compteur de variables à 5.
Surchargez la signification de l'opérateur -.
L'opérateur décrémentera la valeur de la variable x de 1.
Fin de la section de surcharge de l'opérateur. L'opérateur a reçu un nouveau nom.
Définition d'une fonction nommée fonction Display ().
Imprimez la valeur du nombre de variables à côté d'un autre texte sur la console lorsque la fonction Display () est appelée. Le} marque la fin du corps de la fonction Display ().
Fin du corps de la classe.
Appelez la fonction main (). La logique du programme doit être ajoutée dans cette fonction.
Créez une instance de la classe TestClass et donnez-lui le nom tc.
Cela appellera l'opérateur void - () fonction.
Utilisez la position de TestClass Class pour appeler la fonction Display ().
La fonction doit renvoyer une valeur une fois terminée.
Fin du corps de la fonction main ().

Différentes approches de la surcharge d'opérateurs en C ++

Vous pouvez effectuer une surcharge d'opérateur en implémentant l'un des types de fonctions suivants:

Fonction de membre
Fonction non-membre
Fonction ami

La fonction de surcharge d'opérateur peut être une fonction membre lorsqu'un opérande Left est un objet de la classe.
Lorsque l'opérande Left est différent, la fonction de surcharge de l'opérateur doit être une fonction non membre.

Vous pouvez faire de la fonction de surcharge d'opérateur une fonction amie si elle a besoin d'accéder aux membres de classe privé et protégé.

Tous les opérateurs C ++ peuvent-ils être surchargés?

Non. Il existe des opérateurs C ++ qui ne peuvent pas être surchargés.

Ils incluent:

:: -Opérateur de résolution d'oscilloscope
?: -opérateur alternatif.
. -sélecteur de membre
Taille de l'opérateur
* -membre sélecteur de pointeur

Choses dont il faut se rappeler:

Avec la surcharge d'opérateurs, vous pouvez redéfinir la manière dont un opérateur fonctionne uniquement pour les types définis par l'utilisateur (objets, structures). Vous ne pouvez pas l'utiliser pour les types intégrés (float, char, int, etc.).
Les opérateurs = et & C ++ sont surchargés par défaut. Par exemple, vous pouvez copier les objets de la même classe directement à l'aide de l'opérateur =.
La priorité des opérateurs ne change pas l'association et la priorité des opérateurs. Cependant, vous pouvez modifier l'ordre d'évaluation en utilisant des parenthèses.
Il existe quatre opérateurs que vous ne pouvez pas surcharger en C ++. Ils incluent l'opérateur de résolution de portée (: :), l'opérateur de sélection de membre (.), La sélection de membre via un pointeur vers l'opérateur de fonction (. *) Et l'opérateur ternaire (? :).

Règles de surcharge des opérateurs:

Voici les règles de surcharge des opérateurs:

Pour que cela fonctionne, au moins un opérande doit être un objet de classe défini par l'utilisateur.
Vous ne pouvez surcharger que les opérateurs existants. Vous ne pouvez pas surcharger les nouveaux opérateurs.
Certains opérateurs ne peuvent pas être surchargés à l'aide d'une fonction ami. Cependant, ces opérateurs peuvent être surchargés à l'aide de la fonction membre.

Comment surcharger l'opérateur:

Exemple 1:

#include using namespace std;class OperatorOverload {private:int x;public:OperatorOverload() : x(10) {}void operator ++() {x = x + 2;}void Print() {cout << "The Count is: " << x;}};int main() {OperatorOverload ov;++ov;ov.Print();return 0;}

Production:

Voici une capture d'écran du code:

Explication du code:

Inclure le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
Créez une classe nommée OperatorOverload.
Utilisez le modificateur d'accès privé, qui marque un membre de classe comme accessible en privé.
Créez une variable entière x. Cette variable sera accessible en privé.
Utilisez le modificateur d'accès public, qui marque un membre de classe comme accessible en privé.
Utilisez un constructeur de classe pour initialiser la variable x à 10.
Surchargez la signification de l'opérateur ++.
L'opérateur incrémentera la valeur de la variable x de 2.
Fin de la section de surcharge de l'opérateur. L'opérateur a reçu un nouveau nom.
Appel de la fonction Imprimer ().
Imprimez la valeur de la variable x avec un autre texte sur la console lorsque la fonction Print () est appelée.
Fin du corps de la fonction Print ().
Fin du corps de la classe.
Appelez la fonction main (). La logique du programme doit être ajoutée dans cette fonction.
Créez une instance de la classe OperatorOverload nommée ov.
Cela appellera la fonction void operator ++ ().
Utilisez la position de la classe OperatorOverload pour appeler la fonction Print ().
La fonction doit renvoyer une valeur une fois terminée.
Fin du corps de la fonction main ().

Exemple 2:

#includeusing namespace std;class TestClass {private:int real, over;public:TestClass(int rl = 0, int ov = 0) {real = rl;over = ov;}TestClass operator + (TestClass const &obj) {TestClass result;result.real = real + obj.real;result.over = over + obj.over;return result;}void print() {cout << real << " + i" << over << endl;}};int main(){TestClass c1(9, 5), c2(4, 3);TestClass c3 = c1 + c2;c3.print();}

Production:

Voici une capture d'écran du code:

Explication du code:

Inclure le fichier d'en-tête iostream dans notre programme afin d'utiliser ses fonctions.
Incluez l'espace de noms std dans notre programme afin d'utiliser ses classes sans l'appeler.
Créez une classe nommée TestClass. Le {marque le début du corps de la classe.
Utilisez le modificateur d'accès privé pour marquer les variables comme privées, ce qui signifie qu'elles ne sont accessibles qu'à partir de la classe.
Définissez deux variables entières, réelles et supérieures.
Utilisez le modificateur d'accès public pour marquer le constructeur comme public, ce qui signifie qu'il sera accessible même en dehors de la classe.
Création du constructeur de classe et initialisation des variables.
Initialisez la valeur de la variable real.
Initialisez la valeur de la variable over.
Fin du corps du constructeur.
Remplacez la signification de l'opérateur +.
Créez le résultat du type de données de type TestClass.
Utilisez l'opérateur + avec des nombres complexes. Cette ligne ajoutera la partie réelle d'un nombre à la partie réelle d'un autre nombre.
Utilisez l'opérateur + avec des nombres complexes. Cette ligne ajoutera la partie imaginaire d'un nombre à la partie imaginaire d'un autre nombre.
Le programme renverra la valeur du résultat de la variable après une exécution réussie.
Fin de la définition de la nouvelle signification de l'opérateur +, c'est-à-dire surcharge.
Appelez la méthode print ().
Imprimez le nouveau nombre complexe après l'ajout sur la console.
Fin du corps de la fonction print ().
Fin du corps de la classe TestClass.
Appel de la fonction main ().
Passer les valeurs des pièces réelles et complexes à ajouter. La première partie de c1 sera ajoutée à la première partie de c2, c'est-à-dire 9 + 4. La deuxième partie de c1 sera ajoutée à la deuxième partie de c, c'est-à-dire 5 + 3.
Exécution d'une opération à l'aide de l'opérateur surchargé + et stockage du résultat dans la variable c3.
Impression de la valeur de la variable c3 sur la console.
Fin du corps de la fonction main ().

Résumé:

Vous pouvez spécifier plusieurs significations pour un opérateur C ++ dans une même étendue.
C'est ce qu'on appelle la surcharge des opérateurs.
La surcharge d'opérateur donne une signification particulière à un opérateur pour un type de données défini par l'utilisateur.
Vous pouvez redéfinir la majorité des opérateurs C ++ via la surcharge d'opérateurs.
Tous les opérateurs C ++ ne peuvent pas être surchargés.
Pour qu'un opérateur soit surchargé, au moins l'un des opérandes doit être un objet défini par l'utilisateur.
Seuls les opérateurs existants peuvent être surchargés. Vous ne pouvez pas surcharger les nouveaux opérateurs.