C++ Operator‑Overloading: Praktischer Leitfaden mit Code‑Beispielen

Was ist Operator‑Overloading?

Mithilfe von Operator‑Overloading in C++ können Sie einem Operator innerhalb desselben Gültigkeitsbereichs mehrere Bedeutungen zuweisen. Ziel ist es, einem Operator für einen benutzerdefinierten Typ ein individuelles Verhalten zu geben.

Durch Operator‑Overloading können Sie die meisten C++‑Operatoren neu definieren und unterschiedliche Operationen mit einem einzigen Symbol durchführen.

In diesem Tutorial lernen Sie:

• Was Operator‑Overloading ist
• Syntax
• Verschiedene Ansätze zum Overloading in C++
• Welche Operatoren nicht überladen werden können
• Wichtige Überlegungen
• Regeln für Operator‑Overloading
• Wie man einen Operator in der Praxis überlädt

Syntax

Um einen C++‑Operator zu überladen, definieren Sie eine spezielle Member‑Funktion innerhalb einer Klasse wie folgt:

class klassen_name {
    ...
public:
    rueckgabetyp operator symbol (parameter) {
        ...
    }
    ...
};

Die Bestandteile sind:

• rueckgabetyp – der von der Operator‑Funktion zurückgegebene Typ.
• operator – das Schlüsselwort, das die Deklaration einleitet.
• symbol – der zu überladende Operator, z. B. +, -, <, ++.
• parameter – Parameter wie bei jeder anderen Funktion.

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:

Screenshot des Codes:

Code‑Erklärung:

1. <iostream> für I/O einbinden.
2. std‑Namespace für Kürze.
3. Klasse TestClass definieren.
4. count als privates Datenelement.
5. Öffentlicher Konstruktor initialisiert count mit 5.
6. Präfix‑-- Operator überladen, um 3 von count abzuziehen.
7. Display() implementieren, um aktuellen Wert auszugeben.
8. In main() Instanz erzeugen, überladenen Operator anwenden, Ergebnis anzeigen.

Verschiedene Ansätze zum Operator‑Overloading in C++

Overloading kann erreicht werden durch:

1. Member‑Funktionen
2. Nicht‑Member‑Funktionen (Friend‑ oder freie Funktionen)
3. Friend‑Funktionen (wenn Zugriff auf private Daten nötig)

• Ist der linke Operand ein Objekt der Klasse, wird typischerweise eine Member‑Funktion verwendet.
• Ist der linke Operand eines anderen Typs, ist eine Nicht‑Member‑Funktion erforderlich.
• Friend‑Funktionen sind nützlich, wenn der Operator auf private/geschützte Member zugreifen muss.

Können alle C++‑Operatoren überladen werden?

Nein. Folgende Operatoren sind nicht überladbar:

• :: – Scope‑Resolution
• ?: – Ternärer Bedingungsoperator
• . – Member‑Zugriff
• sizeof – Größenabfrage
• * (Member‑Pointer‑Selektor)

Wichtige Hinweise

1. Overloading betrifft nur benutzerdefinierte Typen; eingebaute Typen behalten ihr ursprüngliches Verhalten.
2. Zuweisungs‑(=) und Adress‑Operator (&) werden automatisch für Klassen überladen, die Kopierkonstruktor oder Zuweisungsoperator bereitstellen.
3. Operator‑Priorität bleibt unverändert; Klammern können die Auswertungsreihenfolge erzwingen.
4. Drei Operatoren – ::, ., ?: – sind explizit vom Overloading ausgeschlossen.

Regeln für Operator‑Overloading

• Mindestens ein Operand muss ein benutzerdefinierter Klassentyp sein.
• Nur existierende Operatoren können überladen werden; neue Operatorsymbole können nicht eingeführt werden.
• Einige Operatoren (z. B. new, delete) können nicht als Friend‑Funktionen, wohl aber als Member‑Funktionen überladen werden.

Einen Operator überladen – Schritt für Schritt

Beispiel 1: Inkrement‑Operator

#include <iostream>
using namespace std;
class OperatorOverload {
private:
    int x;
public:
    OperatorOverload() : x(10) {}
    void operator ++() {
        x += 2;
    }
    void Print() {
        cout << "The Count is: " << x;
    }
};
int main() {
    OperatorOverload ov;
    ++ov;
    ov.Print();
    return 0;
}

Ausgabe:

Screenshot des Codes:

Code‑Erklärung:

1. <iostream> und std‑Namespace.
2. Klasse OperatorOverload mit privatem int x.
3. Konstruktor initialisiert x mit 10.
4. Präfix‑++ überladen, um 2 zu x addieren.
5. Print() zum Anzeigen des aktualisierten Werts.
6. In main() Objekt erzeugen, überladenen Operator aufrufen, Ergebnis drucken.

Beispiel 2: Addition komplexer Zahlen

#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:

Screenshot des Codes:

Code‑Erklärung:

1. <iostream> und std‑Namespace.
2. TestClass mit real und over Komponenten.
3. Konstruktor für Initialisierung.
4. + Operator überladen für komplexe Addition.
5. Neue TestClass‑Instanz mit Summe zurückgeben.
6. print() zur Anzeige der komplexen Zahl.
7. In main() zwei Instanzen erzeugen, addieren, Ergebnis drucken.

Zusammenfassung

• Operator‑Overloading erlaubt mehrere Bedeutungen für einen Operator in einem Gültigkeitsbereich.
• Es bietet benutzerdefiniertes Verhalten für benutzerdefinierte Typen.
• Die meisten C++‑Operatoren können überladen werden, aber einige nicht.
• Mindestens ein Operand muss ein benutzerdefinierter Typ sein.
• Nur existierende Operatoren sind überladbar.