C++ OperaTor-Überladung mit Beispielen

Syntax

Um einen C++ Operator sollten Sie eine spezielle Funktion innerhalb der Klasse wie folgt definieren:

class class_name
{
    ... .. ...
    public
       return_type operator symbol (argument(s))
       {
           ... .. ...
       } 
    ... .. ...
};

Hier ist eine Erklärung für die obige Syntax:

• Der return_type ist der Rückgabetyp für die Funktion.
• Als nächstes erwähnen Sie das Operatorschlüsselwort.
• Das Symbol bezeichnet das zu überladende Operatorsymbol. Beispielsweise +, -, <, ++.
• Die Argumente können auf die gleiche Weise wie Funktionen an die Operatorfunktion übergeben werden.

Beispiel 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen TestClass.
4. Verwenden Sie den privaten Zugriffsmodifikator, der ein Klassenmitglied als privat zugänglich markiert.
5. Erstellen Sie eine ganzzahlige Variablenanzahl. Auf diese Variable kann privat zugegriffen werden.
6. Verwenden Sie den Modifikator für den öffentlichen Zugriff, der ein Klassenmitglied als privat zugänglich markiert.
7. Verwenden Sie einen Klassenkonstruktor, um den Variablenzähler auf 5 zu initialisieren.
8. Überladen Sie die Bedeutung des —-Operators.
9. Der Operator verringert den Wert der Variablen x um 1.
10. Ende des Abschnitts zur Operatorüberladung. Der Operator hat einen neuen Namen erhalten.
11. Definieren einer Funktion namens Display()-Funktion.
12. Geben Sie den Wert der Variablenanzahl zusammen mit anderem Text auf der Konsole aus, wenn die Funktion Display() aufgerufen wird. Das } markiert das Ende des Hauptteils der Display()-Funktion.
13. Ende des Unterrichtskörpers.
14. Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb dieser Funktion hinzugefügt werden.
15. Erstellen Sie eine Instanz der Klasse TestClass und geben Sie ihr den Namen tc.
16. Dadurch wird die Funktion void operator –() aufgerufen.
17. Verwenden Sie die Haltung der TestClass-Klasse, um die Funktion Display() aufzurufen.
18. Die Funktion muss nach erfolgreichem Abschluss einen Wert zurückgeben.
19. Ende des Hauptteils der Funktion main().

Verschiedene Ansätze zu Operator Überlastung in C++

Sie können eine Operatorüberladung durchführen, indem Sie einen der folgenden Funktionstypen implementieren:

1. Mitgliedsfunktion
2. Nicht-Mitgliedsfunktion
3. Friend-Funktion

• Die Operatorüberladungsfunktion kann eine Mitgliedsfunktion sein, wenn ein linker Operand ein Objekt der Klasse ist.
• Wenn der linke Operand unterschiedlich ist, OperaDie Tor-Überladungsfunktion sollte eine Nicht-Member-Funktion sein.

Sie können die Operatorüberladungsfunktion zu einer Friend-Funktion machen, wenn sie auf die privaten und geschützten Klassenmitglieder zugreifen muss.

Können alle C++ OperaToren überlastet sein?

Nein. Es gibt C++ Operatoren, die nicht überladen werden können.

Die Zertifizierungen umfassen im Einzelnen:

• :: -Bereichsauflösungsoperator
• ?: -ternärer Operator.
• . -Mitgliedsauswahl
• Sizeof-Operator
• * -Member-Zeigerselektor

Dinge zu erinnern,

1. Mit der Operatorüberladung können Sie die Funktionsweise eines Operators nur für benutzerdefinierte Typen (Objekte, Strukturen) neu definieren. Sie können sie nicht für integrierte Typen (Float, Char, Int usw.) verwenden.
2. Das = und & C++ Operatoren sind standardmäßig überladen. Beispielsweise können Sie die Objekte derselben Klasse direkt mit dem Operator = kopieren.
3. OperaDie Priorität von Operatoren ändert nicht die Assoziativität und Priorität von Operatoren. Sie können jedoch die Reihenfolge der Auswertung mithilfe von Klammern ändern.
4. Es gibt vier Operatoren, die Sie nicht überladen können in C++. Dazu gehören der Bereichsauflösungsoperator (::), der Mitgliedsauswahloperator (.), die Mitgliedsauswahl über einen Zeiger auf einen Funktionsoperator (.*) und der ternäre Operator (?:).

Regeln für Operator Überlastung

Hier sind Regeln für OperaTor-Überladung:

• Damit dies funktioniert, muss mindestens ein Operand ein benutzerdefiniertes Klassenobjekt sein.
• Sie können nur vorhandene Operatoren überladen. Sie können keine neuen Operatoren überladen.
• Einige Operatoren können nicht mit einer Friend-Funktion überladen werden. Solche Operatoren können jedoch mit einer Member-Funktion überladen werden.

So überladen Sie OperaDo.

Beispiel 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen OperatorOverload.
4. Verwenden Sie den privaten Zugriffsmodifikator, der ein Klassenmitglied als privat zugänglich markiert.
5. Erstellen Sie eine ganzzahlige Variable x. Auf diese Variable kann privat zugegriffen werden.
6. Verwenden Sie den Modifikator für den öffentlichen Zugriff, der ein Klassenmitglied als privat zugänglich markiert.
7. Verwenden Sie einen Klassenkonstruktor, um die Variable x auf 10 zu initialisieren.
8. Überladen Sie die Bedeutung des ++-Operators.
9. Der Operator erhöht den Wert der Variablen x um 2.
10. Ende des Abschnitts zur Operatorüberladung. Der Operator hat einen neuen Namen erhalten.
11. Aufruf der Funktion Print().
12. Drucken Sie den Wert der Variablen x zusammen mit anderem Text auf der Konsole, wenn die Funktion Print() aufgerufen wird.
13. Ende des Hauptteils der Print()-Funktion.
14. Ende des Unterrichtskörpers.
15. Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb dieser Funktion hinzugefügt werden.
16. Erstellen Sie eine Instanz von OperatorOverload-Klasse mit dem Namen ov.
17. Dadurch wird die Funktion void operator ++() aufgerufen.
18. Benutzen Sie die Haltung von OperatorOverload-Klasse zum Aufrufen der Print()-Funktion.
19. Die Funktion muss nach erfolgreichem Abschluss einen Wert zurückgeben.
20. Ende des Hauptteils der Funktion main().

Beispiel 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();
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unser Programm, um dessen Funktionen nutzen zu können.
2. Fügen Sie den std-Namespace in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen TestClass. Das { markiert den Anfang des Klassenkörpers.
4. Verwenden Sie den privaten Zugriffsmodifikator, um Variablen als privat zu markieren, was bedeutet, dass auf sie nur innerhalb der Klasse zugegriffen werden kann.
5. Definieren Sie zwei ganzzahlige Variablen, reell und über.
6. Verwenden Sie den Zugriffsmodifikator public, um den Konstruktor als öffentlich zu markieren, was bedeutet, dass er auch außerhalb der Klasse zugänglich ist.
7. Erstellen des Klassenkonstruktors und Initialisieren des Variablen.
8. Initialisieren Sie den Wert der Variablen real.
9. Initialisieren Sie den Wert der Variablen über.
10. Ende des Konstruktorkörpers.
11. Überschreibt die Bedeutung des +-Operators.
12. Erstellen Sie den Datentyp Ergebnis vom Typ TestClass.
13. Verwenden Sie den Operator + mit komplexen Zahlen. Diese Zeile addiert den Realteil einer Zahl zum Realteil einer anderen Zahl.
14. Verwenden Sie den Operator + mit komplexen Zahlen. Diese Zeile addiert den Imaginärteil einer Zahl zum Imaginärteil einer anderen Zahl.
15. Bei erfolgreicher Ausführung gibt das Programm den Wert der Variablen result zurück.
16. Ende der Definition der neuen Bedeutung des +-Operators, d. h. Überladung.
17. Rufen Sie die print()-Methode auf.
18. Drucken Sie die neue komplexe Zahl nach der Addition auf der Konsole.
19. Ende des Hauptteils der print()-Funktion.
20. Ende des Hauptteils der TestClass-Klasse.
21. Aufruf der Funktion main().
22. Übergeben Sie die Werte der zu addierenden Real- und Komplexteile. Der erste Teil von c1 wird zum ersten Teil von c2 addiert, also 9+4. Der zweite Teil von c1 wird zum zweiten Teil von c addiert, also 5+3.
23. Ausführen einer Operation mit dem überladenen Operator „+“ und Speichern des Ergebnisses in der Variablen c3.
24. Drucken des Werts der Variablen c3 auf der Konsole.
25. Ende des Hauptteils der Funktion main().

Zusammenfassung

• Sie können mehr als eine Bedeutung für a angeben C++ Operator in einem Umfang.
• Dies wird als Operatorüberladung bezeichnet.
• OperaTor-Überladung verleiht einem Operator eine spezielle Bedeutung für einen benutzerdefinierten Datentyp.
• Sie können die Mehrheit der C++ Operatoren durch Operatorüberladung.
• Nicht alle C++ Operatoren können überlastet werden.
• Damit ein Operator überladen werden kann, muss mindestens einer der Operanden ein benutzerdefiniertes Objekt sein.
• Nur vorhandene Operatoren können überladen werden. Neue Operatoren können nicht überladen werden.