Überladen von C ++ - Operatoren (mit Beispielen)

In diesem Tutorial lernen wir anhand von Beispielen das Überladen von Operatoren kennen.

In C ++ können wir die Funktionsweise von Operatoren für benutzerdefinierte Typen wie Objekte und Strukturen ändern. Dies wird als Überlastung des Bedieners bezeichnet . Beispielsweise,

Angenommen, wir haben drei Objekte c1, c2 erstellt und ergeben sich aus einer Klasse mit dem Namen Complex, die komplexe Zahlen darstellt.

Da wir durch Überladen von Operatoren die Funktionsweise von Operatoren ändern können, können wir die Funktionsweise des +Operators neu definieren und die komplexen Zahlen von c1 und c2 hinzufügen, indem wir den folgenden Code schreiben:

 result = c1 + c2;

statt so etwas

 result = c1.addNumbers(c2);

Dies macht unseren Code intuitiv und leicht verständlich.

Hinweis: Wir können nicht verwenden Operator für grundlegende Datentypen Überlastung wie int, float, charund so weiter.

Syntax für das Überladen von C ++ - Operatoren

Um einen Operator zu überladen, verwenden wir eine spezielle operatorFunktion.

 class className (… public returnType operator symbol (arguments) (… )… );

Hier,

returnType ist der Rückgabetyp der Funktion.
Operator ist ein Schlüsselwort.
symbolist der Operator, den wir überladen möchten. Wie: +, <, -, ++, usw.
arguments sind die an die Funktion übergebenen Argumente.

Überladung von Operatoren bei unären Operatoren

Unäre Operatoren arbeiten nur mit einem Operanden. Der Inkrementoperator ++und der Dekrementoperator --sind Beispiele für unäre Operatoren.

Beispiel 1: Überladen des ++ Operators (unärer Operator)

 // Overload ++ when used as prefix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ ()" function ++count1; count1.display(); return 0; )

Ausgabe

 Anzahl: 6

Wenn wir hier verwenden ++count1;, void operator ++ ()wird das aufgerufen. Dies erhöht das Wertattribut für die Objektanzahl1 um 1.

Hinweis: Wenn wir Operatoren überladen, können wir damit nach Belieben arbeiten. Zum Beispiel hätten wir ++den Wert um 100 erhöhen können.

Dies macht unseren Code jedoch verwirrend und schwer verständlich. Es ist unsere Aufgabe als Programmierer, die Überladung von Bedienern richtig und auf konsistente und intuitive Weise zu nutzen.

Das obige Beispiel funktioniert nur, wenn ++es als Präfix verwendet wird. Um die ++Arbeit als Postfix zu ermöglichen, verwenden wir diese Syntax.

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

Beachten Sie das intInnere der Klammern. Dies ist die Syntax für die Verwendung unärer Operatoren als Postfix. Es ist kein Funktionsparameter.

Beispiel 2: Überladen des ++ Operators (unärer Operator)

 // Overload ++ when used as prefix and postfix #include using namespace std; class Count ( private: int value; public: // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix void operator ++ () ( ++value; ) // Overload ++ when used as postfix void operator ++ (int) ( ++value; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1; // Call the "void operator ++ (int)" function count1++; count1.display(); // Call the "void operator ++ ()" function ++ count1; count1.display(); return 0; )

Ausgabe

 Anzahl: 6 Anzahl: 7

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

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

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

 // return Count when ++ used as prefix Count operator ++ () ( // code ) // return Count when ++ used as postfix Count operator ++ (int) ( // code )

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

 #include using namespace std; class Count ( private: int value; public : // Constructor to initialize count to 5 Count() : value(5) () // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) // Overload ++ when used as postfix Count operator ++ (int) ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; ) void display() ( cout << "Count: " << value << endl; ) ); int main() ( Count count1, result; // Call the "Count operator ++ ()" function result = ++count1; result.display(); // Call the "Count operator ++ (int)" function result = count1++; result.display(); return 0; )

Ausgabe

 Anzahl: 6 Anzahl: 7

Hier haben wir den folgenden Code zum Überladen von Präfixoperatoren verwendet:

 // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; )

Der Code für das Überladen des Postfix-Operators ist ebenfalls der gleiche. Beachten Sie, dass wir eine Objekttemperatur erstellt und ihren Wert an die Operatorfunktion zurückgegeben haben.

Beachten Sie auch den Code

 temp.value = ++value;

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

Überladung von Operatoren in Binäroperatoren

Binäroperatoren arbeiten an zwei Operanden. Beispielsweise,

 result = num + 9;

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

Wenn wir den Binäroperator für benutzerdefinierte Typen mithilfe des Codes überladen:

 obj3 = obj1 + obj2;

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

Beispiel 4: Überladen von C ++ - Binäroperatoren

 // C++ program to overload the binary operator + // This program adds two complex numbers #include using namespace std; class Complex ( private: float real; float imag; public: // Constructor to initialize real and imag to 0 Complex() : real(0), imag(0) () void input() ( cout <> real; cin>> imag; ) // Overload the + 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 << "Output Complex number: " << real << imag << "i"; else cout << "Output Complex number: " << real << "+" << imag << "i"; ) ); int main() ( Complex complex1, complex2, result; cout << "Enter first complex number:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Ausgabe

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

In diesem Programm lautet die Bedienerfunktion:

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

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

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

Jedoch,

Mit using &wird unser Code effizienter, indem auf das complex2-Objekt verwiesen wird, anstatt ein doppeltes Objekt innerhalb der Operatorfunktion zu erstellen.
Die Verwendung constwird als bewährte Methode angesehen, da sie verhindert, dass die Operatorfunktion complex2 ändert.

Überladen von Binäroperatoren in C ++

Dinge, die Sie beim Überladen von C ++ - Operatoren beachten sollten

Zwei Operatoren =und &sind in C ++ bereits standardmäßig überladen. Um beispielsweise Objekte derselben Klasse zu kopieren, können wir den =Operator direkt verwenden . Wir müssen keine Operatorfunktion erstellen.
Das Überladen von Operatoren kann die Priorität und Assoziativität von Operatoren nicht ändern. Wenn wir jedoch die Reihenfolge der Auswertung ändern möchten, sollten Klammern verwendet werden.
Es gibt 4 Operatoren, die in C ++ nicht überladen werden können. Sie sind:
1. :: (Scope Resolution)
2. . (Mitgliederauswahl)
3. .* (Elementauswahl durch Zeiger auf Funktion)
4. ?: (ternärer Operator)