In diesem Artikel werden wir ein weiteres objektorientiertes Konzept untersuchen, das die Bedienung durch den Bediener vereinfacht. Das heißt, wir würden auf die Details des Betreibers eingehen Überladen in C ++ . Die folgenden Hinweise werden in diesem Artikel behandelt:
- Überladen in C ++
- Arten der Überladung in C ++
- Warum wird eine Überlastung des Bedieners verwendet?
- Implementieren der Operatorüberladung in C ++
- Arten von Überlastungsansätzen
- Überladen von unären Operatoren
- Überladen von Binäroperatoren
Beginnen wir also mit diesem Artikel über das Überladen von Operatoren in C ++.
Überladen in C ++
Wenn wir zwei oder mehr Mitglieder derselben Klasse mit demselben Namen, aber unterschiedlicher Anzahl oder Art des Parameters erstellen, wird dies als C ++ - Überladung bezeichnet.
In C ++ können wir überladen:
- Methoden
- Konstruktoren
- indizierte Eigenschaften
Dies liegt daran, dass diese Mitglieder nur Parameter haben.
Fahren Sie mit diesem Artikel über das Überladen von Operatoren in C ++ fort.
Arten der Überladung in C ++
- Funktionsüberladung
- Überlastung des Bedieners
Fahren Sie mit diesem Artikel über das Überladen von Operatoren in C ++ fort.
Warum wird eine Überlastung des Bedieners verwendet?
C ++ - Programme können ohne Kenntnis der Operatorüberladung geschrieben werden. Auch die Bedienung des Bedieners wird von Programmierern intensiv genutzt, um das Programm intuitiv zu gestalten. Beispielsweise,
Wir können den Code wie folgt ersetzen:
Berechnung = addieren (dividieren (a, b), multiplizieren (a, b))
Für die Gleichung
Berechnung = (a / b) + (a * b)
Das Überladen von Operatoren bietet eine einfache Möglichkeit für die Entwicklung neuer Definitionen für die meisten Operatoren in C ++. Mit ausreichendem Wissen können wir durch den kreativen Einsatz der Funktions- und Operatorüberladungstechniken fast eine eigene neue Sprache erstellen. Wir können alle Operatoren in C ++ außer den folgenden überladen:
● Bereichsoperator (: :)
● Größenoperator (Sizeof)
● Mitgliedsauswahl (.)
● Elementzeigerauswahl (*)
● ternärer Operator (? :)
Javascript-Ereignisliste mit Beispielen
Syntax der Operatorüberladung
return_type class_name :: operator op (argument_list) {// Funktionskörper}Dabei ist der Rückgabetyp der von der Funktion zurückgegebene Werttyp. Klassenname ist der Name der Klasse.
Fahren Sie mit diesem Artikel über das Überladen von Operatoren in C ++ fort.
Implementieren der Operatorüberladung in C ++
Die Operatorfunktion muss entweder nicht statisch (Member-Funktion) oder Friend-Funktion sein, um überlastet zu werden. Die Operatorüberladungsfunktion kann auf eine Elementfunktion angewendet werden, wenn der linke Operand ein Objekt dieser Klasse ist. Wenn sich der linke Operand jedoch unterscheidet, muss die Operatorüberladungsfunktion als Nichtmitgliedsfunktion definiert werden.
Die Operatorüberladungsfunktion kann zur Friend-Funktion gemacht werden, wenn Zugriff auf die privaten und geschützten Mitglieder der Klasse erforderlich ist. Beispielsweise ist der Operator op eine Operatorfunktion, wobei op der überladene Operator und der Operator das Schlüsselwort ist. Eine Überladung des Bedieners kann erreicht werden, indem eine Funktion implementiert wird, die entweder eine Mitgliedsfunktion, eine Nichtmitgliedsfunktion oder eine Freundfunktion sein kann.
Was ist der Unterschied zwischen Bedienerfunktionen und normalen Funktionen?
Bedienfunktionen sind die gleichen wie bei normalen Funktionen. Der einzige Unterschied besteht darin, dass der Name einer Operatorfunktion immer das Operatorschlüsselwort gefolgt vom Symbol des Operators ist und Operatorfunktionen aufgerufen werden, wenn der entsprechende Operator verwendet wird.
Fahren Sie mit diesem Artikel über das Überladen von Operatoren in C ++ fort.
Arten von Überlastungsansätzen
Das Überladen von Bedienern kann mithilfe von drei Ansätzen erfolgen
- Überladen eines unären Operators.
- Überladen des Binäroperators.
- Überladen des Binäroperators mithilfe einer Friend-Funktion.
Fahren Sie mit diesem Artikel über das Überladen von Operatoren in C ++ fort.
Überladen des unären Operators
Betrachten wir den unären Operator '-'. Ein Minusoperator benötigt bei Verwendung als unär nur einen Operanden. Wir wissen, dass dieser Operator das Vorzeichen eines Operanden ändert, wenn er auf eine Basisdatenvariable angewendet wird. Lassen Sie uns sehen, wie dieser Operator überladen wird, damit er auf ein Objekt angewendet werden kann, ähnlich wie er auf eine int- oder float-Variable angewendet wird. Das unäre Minus sollte, wenn es auf ein Objekt angewendet wird, jedes seiner Datenelemente dekrementieren.
Beispiel:
Wie schreibe ich einen Scanner in Java?
#include using namespace std class Höhe {public: // Elementobjekte int Fuß, Zoll // Konstruktor zum Initialisieren des Objektwerts Höhe (int f, int i) {Fuß = f Zoll = i} // Überladen des Operators (-) auf Dekrementierung // Operation des Höhenobjekts durchführen void operator- () {feet-- inch-- cout<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch < Ausgabe:
Erläuterung:
Im obigen Beispiel überladen wir den unären Operator '-', um die beiden Variablen der Höhenklasse zu dekrementieren. Wir übergeben zwei Parameter an den Konstruktor und speichern ihre Werte in Fuß und Zoll. Dann definieren wir die Operatorüberladungsfunktion (void operator- ()
), in dem die beiden Variablen um eine Position dekrementiert werden.
Wenn wir -h1 schreiben, ruft es die Operatorüberladungsfunktion auf und dekrementiert die an den Konstruktor übergebenen Werte.
Fahren Sie mit diesem Artikel über das Überladen von Operatoren in C ++ fort.
Überladen des Binäroperators
Es ist eine Überlastung eines Operators, der mit zwei Operanden arbeitet. Nehmen wir das gleiche Beispiel für die Klassenhöhe, aber fügen Sie diesmal zwei Höhenobjekte h1 und h2 hinzu.
Beispiel:
#include using namespace std class Höhe {public: int Fuß, Zoll Höhe () {Fuß = 0 Zoll = 0} Höhe (int f, int i) {Fuß = f Zoll = i} // Überladender (+) Operator zum Ausführen Hinzufügen von // zwei Entfernungsobjekten mit dem Binäroperator Höhenoperator + (Höhe & d2) // Aufruf durch Referenz {// Erstellen eines Objekts zur Rückgabe Höhe h3 // Hinzufügen von Fuß und Zoll h3.feet = Fuß + d2.feet h3. inch = inch + d2.inch // Rückgabe des resultierenden Objekts return h3}} int main () {Höhe h1 (3, 7) Höhe h2 (6, 1) Höhe h3 // Überladenen Operator h3 = h1 + h2 cout verwenden<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } Ausgabe:
Erläuterung:
Der Höhenoperator + (Höhe & h2), hier return_type der Funktion ist die Klasse Höhe, daher wird ein Objekt h3 der Klasse Höhe zurückgegeben. In der Zeile h3 = h1 + h2 ruft h1 die Operatorfunktion seiner Klassenobjekte auf und nimmt h2 als Parameter. Dann wenden wir h3.feet = Fuß + d2.feet und h3.inch = inch + d2.inch an, in denen das gespeichert ist Summe der Werte der Variablen Fuß und Zoll in Variablen, die dem h3-Objekt zugeordnet sind.
Wenn die Anweisung 'h3 = h1 + h2' die vom Operator überladene Funktion aufruft, hat das Objekt h1 die Verantwortung für den Aufruf der Funktion übernommen und h2 spielt die Rolle des Arguments, das an die Funktion übergeben wird. Die obige Aufrufanweisung entspricht h3 = h1.operator + (h2), daher wird direkt auf das Datenelement von h2 und auf das Datenelement von h2 (das als Argument übergeben wird) mit dem Punktoperator zugegriffen.
Regeln für das Überladen von Bedienern
- Nur die vorhandenen Operatoren können überladen werden, und neue Operatoren können nicht überladen werden
- Der überladene Operator muss mindestens einen Operanden des benutzerdefinierten Datentyps enthalten.
- Wir verwenden keine Friend-Funktion, um bestimmte Operatoren zu überlasten. Die Elementfunktionen können jedoch verwendet werden, um diese Operatoren zu überladen.
- Wenn unäre Operatoren durch eine Mitgliedsfunktion überladen werden, nehmen sie keine expliziten Argumente an, aber wenn sie von einer Freundfunktion überladen werden, nehmen sie ein Argument.
- Wenn binäre Operatoren durch eine Mitgliedsfunktion überladen werden, nehmen sie ein explizites Argument an, und wenn sie durch eine Freundfunktion überladen werden, nehmen sie zwei explizite Argumente.
Damit sind wir am Ende dieses Artikels über 'Operator Overloading in C ++' angelangt. Wenn Sie mehr erfahren möchten, lesen Sie das Java-Training von Edureka, einem vertrauenswürdigen Online-Lernunternehmen. Edurekas Der Kurs wurde entwickelt, um Sie sowohl für Kern- als auch für fortgeschrittene Java-Konzepte zusammen mit verschiedenen Java-Frameworks wie Hibernate & Spring zu schulen.
Hast du eine Frage an uns? Bitte erwähne es im Kommentarbereich dieses Blogs und wir werden uns so schnell wie möglich bei dir melden.