Überladen von C++-Operatoren mit Beispielen

Was ist Operatorüberladung?

Verwendung von Operatorüberladung In C++ können Sie mehr als eine Bedeutung für einen Operator in einem Gültigkeitsbereich angeben. Der Zweck des Überladens von Operatoren besteht darin, eine spezielle Bedeutung eines Operators für einen benutzerdefinierten Datentyp bereitzustellen.

Mithilfe der Operatorüberladung können Sie die meisten C++-Operatoren neu definieren. Sie können auch das Überladen von Operatoren verwenden, um verschiedene Operationen mit einem Operator auszuführen.

In diesem C++-Tutorial lernen Sie:

• Was ist Operatorüberladung?
• Syntax
• Verschiedene Ansätze zum Überladen von Operatoren in C++
• Können alle C++-Operatoren überladen werden?
• Hinweise:
• Regeln für das Überladen von Operatoren:
• Überladen des Operators:

Syntax

Um einen C++-Operator zu überladen, 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 Schlüsselwort operator.
• Das Symbol bezeichnet das zu überladende Operatorsymbol. Zum Beispiel +, -, <, ++.
• Das/die Argument(e) kann/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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namensraum in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse namens TestClass.
4. Verwenden Sie den privaten Zugriffsmodifikator, der ein Klassenmitglied als privat zugänglich markiert.
5. Erzeuge einen ganzzahligen Variablenzähler. Diese Variable ist privat zugänglich.
6. Verwenden Sie den öffentlichen Zugriffsmodifikator, 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 dekrementiert den Wert der Variablen x um 1.
10. Ende des Abschnitts zum Überladen von Operatoren. Der Operator hat einen neuen Namen bekommen.
11. Definieren einer Funktion namens Display()-Funktion.
12. Druckt den Wert der Variablen count zusammen mit anderem Text auf der Konsole, wenn die Funktion Display() aufgerufen wird. Das } markiert das Ende des Hauptteils der Funktion Display().
13. Ende des Klassenhauptteils.
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 void-Operatorfunktion –() aufgerufen.
17. Verwenden Sie die Haltung der TestClass-Klasse, um die Display()-Funktion aufzurufen.
18. Die Funktion muss nach erfolgreichem Abschluss einen Wert zurückgeben.
19. Ende des Hauptteils der Funktion main().

Verschiedene Ansätze zum Überladen von Operatoren in C++

Sie können das Überladen von Operatoren durchführen, indem Sie einen der folgenden Funktionstypen implementieren:

1. Mitgliederfunktion
2. Nichtmitgliedsfunktion
3. Freundschaftsfunktion

• Die Funktion zum Überladen des Operators kann eine Mitgliedsfunktion sein, wenn ein linker Operand ein Objekt der Klasse ist.
• Wenn der linke Operand anders ist, sollte die Operator-Überladungsfunktion 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 überladen werden?

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

Dazu gehören:

• ::-Bereichsauflösungsoperator
• ?:-ternärer Operator.
• . -Memberselektor
• Operatorgröße
• * -Memberzeigerselektor

Erinnerungen:

1. Mit dem Überladen von Operatoren können Sie die Funktionsweise eines Operators nur für die benutzerdefinierten Typen (Objekte, Strukturen) neu definieren. Sie können es nicht für eingebaute Typen (float, char, int usw.) verwenden.
2. Die C++-Operatoren =und &sind standardmäßig überladen. Beispielsweise können Sie die Objekte derselben Klasse direkt mit dem =-Operator kopieren.
3. Operatorrangfolge ändert nicht die Assoziation und Rangfolge von Operatoren. Sie können jedoch die Reihenfolge der Auswertung mit Klammern ändern.
4. Es gibt vier Operatoren, die Sie in C++ nicht überladen können. Dazu gehören der Bereichsauflösungsoperator (::), der Elementauswahloperator (.), die Elementauswahl durch einen Zeiger auf den Funktionsoperator (.*) und der ternäre Operator (?:).

Regeln für das Überladen von Operatoren:

Hier sind Regeln für das Überladen von Operatoren:

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

Wie man den Operator überlädt:

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

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namensraum in unser Programm ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse namens OperatorOverload.
4. Verwenden Sie den privaten Zugriffsmodifikator, der ein Klassenmitglied als privat zugänglich markiert.
5. Erstelle eine Integer-Variable x. Diese Variable ist privat zugänglich.
6. Verwenden Sie den öffentlichen Zugriffsmodifikator, 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 zum Überladen von Operatoren. Der Operator hat einen neuen Namen bekommen.
11. Aufruf der Print()-Funktion.
12. Den Wert der Variablen x zusammen mit anderem Text auf der Konsole ausgeben, wenn die Funktion Print() aufgerufen wird.
13. Ende des Hauptteils der Print()-Funktion.
14. Ende des Klassenhauptteils.
15. Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb dieser Funktion hinzugefügt werden.
16. Erstellen Sie eine Instanz der OperatorOverload-Klasse namens ov.
17. Dadurch wird die ++()-Funktion des void-Operators aufgerufen.
18. Verwenden Sie die Haltung der OperatorOverload-Klasse, um die Print()-Funktion aufzurufen.
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();
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unser Programm, um dessen Funktionen zu nutzen.
2. Nehmen Sie den std-Namensraum in unser Programm auf, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse namens 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 Integer-Variablen, real und darüber.
6. Verwenden Sie den öffentlichen Zugriffsmodifikator, um den Konstruktor als öffentlich zu markieren, was bedeutet, dass er sogar außerhalb der Klasse zugänglich ist.
7. Erstellen des Klassenkonstruktors und Initialisieren der Variablen.
8. Initialisieren Sie den Wert der Variablen real.
9. Initialisieren Sie den Wert der Variablen über.
10. Ende des Konstruktorkörpers.
11. Überschreiben Sie die Bedeutung des Operators +.
12. Erstellen Sie das Datentypergebnis 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. Das Programm gibt den Wert der Variable result nach erfolgreicher Ausführung zurück.
16. Ende der Definition der neuen Bedeutung des Operators +, also Überladen.
17. Rufen Sie die Methode print() auf.
18. Drucken Sie die neue komplexe Zahl nach der Addition auf der Konsole.
19. Ende des Hauptteils der Funktion print().
20. Ende des Hauptteils der TestClass-Klasse.
21. Aufruf der main()-Funktion.
22. Übergabe der Werte sowohl reeller als auch komplexer zu addierender Teile. Der erste Teil von c1 wird zum ersten Teil von c2 hinzugefügt, also 9+4. Der zweite Teil von c1 wird zum zweiten Teil von c hinzugefügt, also 5+3.
23. Durchführen einer Operation mit dem überladenen +-Operator und Speichern des Ergebnisses in Variable c3.
24. Den Wert der Variable c3 auf der Konsole ausgeben.
25. Ende des Hauptteils der Funktion main().

Zusammenfassung:

• Sie können mehr als eine Bedeutung für einen C++-Operator in einem Bereich angeben.
• Dies wird als Operatorüberladung bezeichnet.
• Das Überladen von Operatoren bietet eine spezielle Bedeutung eines Operators für einen benutzerdefinierten Datentyp.
• Sie können die meisten C++-Operatoren durch Überladen von Operatoren neu definieren.
• Nicht alle C++-Operatoren können überladen werden.
• Damit ein Operator überladen werden kann, muss mindestens einer der Operanden ein benutzerdefiniertes Objekt sein.
• Nur vorhandene Operatoren können überladen werden. Sie können neue Operatoren nicht überladen.