C++ Operatorüberladung meistern: Praxisbeispiele & Best Practices

C++ Operatorüberladung

In diesem Tutorial lernen Sie Operatorüberladung anhand von Beispielen kennen.

In C++ können wir die Funktionsweise von Operatoren für benutzerdefinierte Typen wie Objekte und Strukturen ändern. Dies nennt man Operatorüberladung. Zum Beispiel:

Angenommen, wir haben drei Objekte c1, c2 und result einer Klasse namens Complex erstellt, die komplexe Zahlen darstellt.

Da Operatorüberladung es uns erlaubt, die Funktionsweise von Operatoren zu ändern, können wir neu definieren, wie der +-Operator funktioniert, und ihn verwenden, um die komplexen Zahlen von c1 und c2 durch folgenden Code zu addieren:

result = c1 + c2;

anstelle von etwas wie

result = c1.addNumbers(c2);

Dies macht unseren Code intuitiv und leicht verständlich.

Hinweis: Wir können Operatorüberladung nicht für fundamentale Datentypen wie int, float, char usw. verwenden.

---

Syntax für C++ Operatorüberladung

Um einen Operator zu überladen, verwenden wir eine spezielle operator-Funktion. Wir definieren die Funktion innerhalb der Klasse oder Struktur, deren Objekte/Variablen mit dem überladenen Operator arbeiten sollen.

class className { ... .. ... public returnType operator symbol (arguments) { ... .. ... } ... .. ... };

Hierbei ist:

• returnType der Rückgabetyp der Funktion.
• operator ein Schlüsselwort.
• symbol der Operator, den wir überladen wollen. Z.B.: +, <, -, ++, etc.
• arguments die an die Funktion übergebenen Argumente.

---

Operatorüberladung bei unären Operatoren

Unäre Operatoren arbeiten mit nur einem Operanden. Der Inkrement-Operator ++ und Dekrement-Operator -- sind Beispiele für unäre Operatoren.

---

Beispiel 1: ++ Operator (Unärer Operator) Überladung

// Überlade ++ bei Verwendung als Präfix #include <iostream> using namespace std; class Count { private: int value; public: // Konstruktor zur Initialisierung von count auf 5 Count() : value(5) {} // Überlade ++ bei Verwendung als Präfix void operator ++ () { ++value; } void display() { cout << "Count: " << value << endl; } }; int main() { Count count1; // Rufe die "void operator ++ ()" Funktion auf ++count1; count1.display(); return 0; }

Ausgabe

Count: 6

Hier wird, wenn wir ++count1; verwenden, die Funktion void operator ++ () aufgerufen. Dies erhöht das value-Attribut für das Objekt count1 um 1.

Hinweis: Wenn wir Operatoren überladen, können wir sie so arbeiten lassen, wie wir möchten. Zum Beispiel hätten wir ++ verwenden können, um value um 100 zu erhöhen.

Dies würde jedoch unseren Code verwirrend und schwer verständlich machen. Es ist unsere Aufgabe als Programmierer, Operatorüberladung ordnungsgemäß und in einer konsistenten und intuitiven Weise zu verwenden.

---

Das obige Beispiel funktioniert nur, wenn ++ als Präfix verwendet wird. Um ++ als Postfix funktionieren zu lassen, verwenden wir diese Syntax.

void operator ++ (int) { // code }

Beachten Sie die int in den Klammern. Es ist die Syntax für die Verwendung unärer Operatoren als Postfix; es ist kein Funktionsparameter.

---

Beispiel 2: ++ Operator (Unärer Operator) Überladung

// Überlade ++ bei Verwendung als Präfix und Postfix #include <iostream> using namespace std; class Count { private: int value; public: // Konstruktor zur Initialisierung von count auf 5 Count() : value(5) {} // Überlade ++ bei Verwendung als Präfix void operator ++ () { ++value; } // Überlade ++ bei Verwendung als Postfix void operator ++ (int) { value++; } void display() { cout << "Count: " << value << endl; } }; int main() { Count count1; // Rufe die "void operator ++ (int)" Funktion auf count1++; count1.display(); // Rufe die "void operator ++ ()" Funktion auf ++count1; count1.display(); return 0; }

Ausgabe

Count: 6 Count: 7

---

Beispiel 2 funktioniert, wenn ++ sowohl als Präfix als auch als Postfix verwendet wird. Es funktioniert jedoch nicht, wenn wir versuchen, etwas wie Folgendes zu tun:

Count count1, result; // Fehler result = ++count1;

Dies liegt daran, dass der Rückgabetyp unserer Operatorfunktion void ist. Wir können dieses Problem lösen, indem wir Count als Rückgabetyp der Operatorfunktion festlegen.

// Count zurückgeben, wenn ++ als Präfix verwendet wird Count operator ++ () { // code } // Count zurückgeben, wenn ++ als Postfix verwendet wird Count operator ++ (int) { // code }

---

Beispiel 3: Rückgabewert aus Operatorfunktion (++ Operator)

#include <iostream> using namespace std; class Count { private: int value; public : // Konstruktor zur Initialisierung von count auf 5 Count() : value(5) {} // Überlade ++ bei Verwendung als Präfix Count operator ++ () { Count temp; // Hier ist value das value-Attribut des aufrufenden Objekts temp.value = ++value; return temp; } // Überlade ++ bei Verwendung als Postfix Count operator ++ (int) { Count temp; // Hier ist value das value-Attribut des aufrufenden Objekts temp.value = value++; return temp; } void display() { cout << "Count: " << value << endl; } }; int main() { Count count1, result; // Rufe die "Count operator ++ ()" Funktion auf result = ++count1; result.display(); // Rufe die "Count operator ++ (int)" Funktion auf result = count1++; result.display(); return 0; }

Ausgabe

Count: 6 Count: 6

Hier haben wir folgenden Code für die Präfix-Operatorüberladung verwendet:

// Überlade ++ bei Verwendung als Präfix Count operator ++ () { Count temp; // Hier ist value das value-Attribut des aufrufenden Objekts temp.value = ++value; return temp; }

Der Code für die Postfix-Operatorüberladung ist ähnlich. Beachten Sie, dass wir ein Objekt temp erstellt und dessen Wert an die Operatorfunktion zurückgegeben haben.

Achten Sie auch auf den Code

temp.value = ++value; 

Die Variable value gehört zum count1-Objekt in main(), da count1 die Funktion aufruft, während temp.value zum temp-Objekt gehört.

---

Operatorüberladung bei binären Operatoren

Binäre Operatoren arbeiten mit zwei Operanden. Zum Beispiel:

result = num + 9;

Hier ist + ein binärer Operator, der auf den Operanden num und 9 arbeitet.

Wenn wir den binären Operator für benutzerdefinierte Typen überladen, indem wir den Code verwenden:

obj3 = obj1 + obj2;

Wird die Operatorfunktion mit dem obj1-Objekt aufgerufen und obj2 wird als Argument an die Funktion übergeben.

---

Beispiel 4: C++ Binärer Operatorüberladung

// C++ Programm zur Überladung des binären Operators + // Dieses Programm addiert zwei komplexe Zahlen #include <iostream> using namespace std; class Complex { private: float real; float imag; public: // Konstruktor zur Initialisierung von real und imag auf 0 Complex() : real(0), imag(0) {} void input() { cout << "Real- und Imaginärteil eingeben: "; cin >> real; cin >> imag; } // Überlade den + Operator Complex operator + (const Complex& obj) { Complex temp; temp.real = real + obj.real; temp.imag = imag + obj.imag; return temp; } void output() { if (imag < 0) cout << "Ausgabe komplexe Zahl: " << real << imag << "i"; else cout << "Ausgabe komplexe Zahl: " << real << "+" << imag << "i"; } }; int main() { Complex complex1, complex2, result; cout << "Erste komplexe Zahl eingeben:\n"; complex1.input(); cout << "Zweite komplexe Zahl eingeben:\n"; complex2.input(); // complex1 ruft die Operatorfunktion auf // complex2 wird als Argument an die Funktion übergeben result = complex1 + complex2; result.output(); return 0; }

Ausgabe

Erste komplexe Zahl eingeben: Real- und Imaginärteil eingeben: 9 5 Zweite komplexe Zahl eingeben: Real- und Imaginärteil eingeben: 7 6 Ausgabe komplexe Zahl: 16+11i

In diesem Programm ist die Operatorfunktion:

Complex operator + (const Complex& obj) { // code }

Stattdessen hätten wir diese Funktion auch so schreiben können:

Complex operator + (Complex obj) { // code }

Jedoch:

• Die Verwendung von & macht unseren Code effizient, indem sie das complex2-Objekt referenziert, anstatt ein Duplikat innerhalb der Operatorfunktion zu erstellen.
• Die Verwendung von const gilt als gute Praxis, da sie verhindert, dass die Operatorfunktion complex2 modifiziert.

---

Wichtige Punkte zur C++ Operatorüberladung

1. Zwei Operatoren = und & sind in C++ standardmäßig bereits überladen. Zum Beispiel können wir zum Kopieren von Objekten derselben Klasse direkt den =-Operator verwenden. Wir müssen keine Operatorfunktion erstellen.
2. Operatorüberladung kann die Priorität und Assoziativität von Operatoren nicht ändern. Wenn wir jedoch die Auswertungsreihenfolge ändern wollen, sollten Klammern verwendet werden.
3. Es gibt 4 Operatoren, die in C++ nicht überladen werden können. Sie sind:
   1. :: (Gültigkeitsbereichsoperator)
   2. . (Mitgliedszugriff)
   3. .* (Mitgliedszugriff über Zeiger auf Funktion)
   4. ?: (ternärer Operator)

---

Empfohlene Weiterführende Themen:

• Wie man den Inkrement-Operator richtig überlädt?
• Wie man den binären Operator - zum Subtrahieren komplexer Zahlen überlädt?