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

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

Utilisation de la surcharge d'opérateur en C++, vous pouvez spécifier plusieurs significations pour un opérateur dans une portée. Le but de la surcharge d'opérateur est de fournir une signification particulière à 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érateurs 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 d'opérateur ?
Syntaxe
Différentes approches de la surcharge d'opérateurs en C++
Tous les opérateurs C++ peuvent-ils être surchargés ?
À retenir :
Règles de surcharge de l'opérateur :
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
{
    ... .. ...
    public
       return_type operator symbol (argument(s))
       {
           ... .. ...
       } 
    ... .. ...
};

Voici une explication de la syntaxe ci-dessus :

Le return_type est le type de retour pour la fonction.
Ensuite, vous mentionnez le mot-clé de l'opérateur.
Le symbole indique 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 <iostream>
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;
}

Sortie :

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 variable à 5.
Surcharger la signification de l'opérateur —.
L'opérateur décrémentera la valeur de la variable x de 1.
Fin de la section sur la surcharge des opérateurs. L'opérateur a reçu un nouveau nom.
Définir une fonction nommée fonction Display().
Imprime la valeur de la variable count à 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 la fonction void operator –().
Utilisez la position de la classe TestClass pour appeler la fonction Display().
La fonction doit renvoyer une valeur en cas de réussite.
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 membre
Fonction non-membre
Fonction ami

La fonction de surcharge d'opérateur peut être une fonction membre lorsqu'un opérande gauche est un objet de la classe.
Lorsque l'opérande gauche 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 de l'opérateur une fonction amie si elle a besoin d'accéder aux membres de la classe privée et protégée.

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

Non. Certains opérateurs C++ ne peuvent pas être surchargés.

Ils incluent :

: - Opérateur de résolution de portée
? :opérateur -ternaire.
. -sélecteur de membres
Taillede l'opérateur
* -sélecteur de pointeur de membre

À retenir :

Avec la surcharge d'opérateurs, vous pouvez redéfinir le fonctionnement d'un opérateur 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 d'une même classe directement à l'aide de l'opérateur =.
La priorité des opérateurs ne modifie 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 membres (.), la sélection de membres via un pointeur vers l'opérateur de fonction (.*) et l'opérateur ternaire (?:).

Règles de surcharge de l'opérateur :

Voici les règles de surcharge de l'opérateur :

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 de 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 <iostream>   
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;
}

Sortie :

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.
Surcharger la signification de l'opérateur ++.
L'opérateur incrémentera la valeur de la variable x de 2.
Fin de la section sur la surcharge des opérateurs. L'opérateur a reçu un nouveau nom.
Appel de la fonction Print().
Imprime la valeur de la variable x à côté d'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 en cas de réussite.
Fin du corps de la fonction main().

Exemple 2 :

#include<iostream> 
using 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();
}

Sortie :

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.
Inclure 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éelle et supérieure.
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.
Initialiser la valeur de la variable real.
Initialiser la valeur de la variable over.
Fin du corps du constructeur.
Remplacer la signification de l'opérateur +.
Créez le résultat du type de données de type TestClass.
Utilisez l'opérateur + avec les 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 les nombres complexes. Cette ligne ajoutera la partie imaginaire d'un nombre à la partie imaginaire d'un autre nombre.
Le programme renverra la valeur de la variable result en cas d'exécution réussie.
Fin de la définition de la nouvelle signification de l'opérateur +, c'est-à-dire la surcharge.
Appelez la méthode print().
Imprimer le nouveau nombre complexe après ajout sur la console.
Fin du corps de la fonction print().
Fin du corps de la classe TestClass.
Appeler la fonction main().
Transmettre les valeurs des parties 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.
Imprimer 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 portée.
C'est ce qu'on appelle la surcharge d'opérateur.
La surcharge d'opérateurs 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++ grâce à 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 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 de nouveaux opérateurs.

Gestion des fichiers C++ :comment ouvrir, écrire, lire et fermer des fichiers en C++ Entrée/Sortie de base C++ :Cout, Cin, Cerr Exemple

Langue C