C++ Operator Surcharge d’exemples

Syntaxe

Pour surcharger un C++ opérateur, 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 de la fonction.
• Ensuite, vous mentionnez le mot-clé opérateur.
• Le symbole désigne le symbole de l'opérateur à surcharger. Par exemple, +, -, <, ++.
• Le ou les arguments peuvent être transmis à 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 :

Code Explication:

1. Inclure le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
3. Créez une classe nommée TestClass.
4. Utilisez le modificateur d'accès privé, qui marque un membre de la classe comme accessible en privé.
5. Créez un nombre de variables entières. Cette variable sera accessible en privé.
6. Utilisez le modificateur d'accès public, qui marque un membre de la classe comme accessible en privé.
7. Utilisez un constructeur de classe pour initialiser le compteur de variable à 5.
8. Surcharger la signification de l'opérateur —.
9. L'opérateur décrémentera la valeur de la variable x de 1.
10. Fin de la section surcharge des opérateurs. L'opérateur a reçu un nouveau nom.
11. Définition d'une fonction nommée fonction Display().
12. Imprimez la valeur du nombre de variables avec un autre texte sur la console lorsque la fonction Display() est appelée. Le } marque la fin du corps de la fonction Display().
13. Fin du corps de classe.
14. Appelez la fonction main(). La logique du programme doit être ajoutée dans cette fonction.
15. Créez une instance de la classe TestClass et donnez-lui le nom tc.
16. Cela appellera la fonction void Operator –().
17. Utilisez la position de TestClass Class pour appeler la fonction Display().
18. La fonction doit renvoyer une valeur une fois terminée avec succès.
19. Fin du corps de la fonction main().

Différentes approches pour Operator Surcharge dans C++

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

1. Fonction membre
2. Fonction non-membre
3. 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 gauche est différent, le OperaLa fonction de surcharge de tor doit être une fonction non membre.

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

Peuvent tous C++ Operales torseurs sont-ils surchargés ?

Non il y a C++ opérateurs qui ne peuvent pas être surchargés.

Ces certifications incluent :

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

Choses dont il faut se rappeler

1. Avec la surcharge d'opérateurs, vous pouvez redéfinir la façon 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.).
2. Le = et & C++ Les opérateurs sont surchargés par défaut. Par exemple, vous pouvez copier directement les objets d'une même classe en utilisant l'opérateur =.
3. OperaLa priorité de tor ne modifie pas l'associativité et la priorité des opérateurs. Cependant, vous pouvez modifier l'ordre d'évaluation en utilisant des parenthèses.
4. Il existe quatre opérateurs que vous ne pouvez pas surcharger 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 pour OperaTor Surcharge

Voici les règles pour OperaTor Surcharge :

• 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 Operator

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 :

Code Explication:

1. Inclure le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
3. Créez une classe nommée OperatorOverload.
4. Utilisez le modificateur d'accès privé, qui marque un membre de la classe comme accessible en privé.
5. Créez une variable entière x. Cette variable sera accessible en privé.
6. Utilisez le modificateur d'accès public, qui marque un membre de la classe comme accessible en privé.
7. Utilisez un constructeur de classe pour initialiser la variable x à 10.
8. Surcharger la signification de l'opérateur ++.
9. L'opérateur incrémentera la valeur de la variable x de 2.
10. Fin de la section surcharge des opérateurs. L'opérateur a reçu un nouveau nom.
11. Appel de la fonction Print().
12. Imprimez la valeur de la variable x avec un autre texte sur la console lorsque la fonction Print() est appelée.
13. Fin du corps de la fonction Print().
14. Fin du corps de classe.
15. Appelez la fonction main(). La logique du programme doit être ajoutée dans cette fonction.
16. Créer une instance du OperatorOverload Classe nommée ov.
17. Cela appellera la fonction void Operator ++().
18. Utilisez la position de Operaclasse torOverload pour appeler la fonction Print().
19. La fonction doit renvoyer une valeur une fois terminée avec succès.
20. 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 :

Code Explication:

1. Inclure le fichier d'en-tête iostream dans notre programme afin d'utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre programme afin d'utiliser ses classes sans l'appeler.
3. Créez une classe nommée TestClass. Le { marque le début du corps de la classe.
4. 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.
5. Définissez deux variables entières, réelles et supérieures.
6. 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.
7. Création du constructeur de classe et initialisation du les variables.
8. Initialisez la valeur de la variable real.
9. Initialisez la valeur de la variable over.
10. Fin du corps constructeur.
11. Remplacez la signification de l’opérateur +.
12. Créez le résultat du type de données de type TestClass.
13. 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.
14. Utilisez l'opérateur + avec les nombres complexes. Cette ligne ajoutera la partie imaginaire d'un nombre à la partie imaginaire d'un autre nombre.
15. Le programme renverra la valeur du résultat variable en cas d'exécution réussie.
16. Fin de la définition du nouveau sens de l'opérateur +, c'est-à-dire la surcharge.
17. Appelez la méthode print().
18. Imprimez le nouveau numéro complexe après ajout sur la console.
19. Fin du corps de la fonction print().
20. Fin du corps de la classe TestClass.
21. Appel de la fonction main().
22. 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, soit 9+4. La deuxième partie de c1 sera ajoutée à la deuxième partie de c, soit 5+3.
23. Effectuer une opération en utilisant l'opérateur + surchargé et stocker le résultat dans la variable c3.
24. Impression de la valeur de la variable c3 sur la console.
25. Fin du corps de la fonction main().

FAQ