Phenquestions
Arithmetische Operatoren werden normalerweise für arithmetische Operationen verwendet. Ist es nicht schön, das + zu haben, zwei Strings zu verbinden?? Wenn man das aktiviert, wird der arithmetische Additionsoperator für Strings überladen.
Der Inkrement-Operator ++ addiert 1 zu einem int oder einem float. Beim Umgang mit Zeigern wird dem Zeiger nicht 1 hinzugefügt. Es bewirkt, dass der Zeiger auf das nächste aufeinander folgende Objekt im Speicher zeigt. Ein Iterator zeigt auf das nächste Objekt in einer verknüpften Liste, aber die verknüpften Listenobjekte befinden sich an verschiedenen Stellen im Speicher (nicht in aufeinanderfolgenden Regionen). Wäre es nicht schön, den Inkrement-Operator für einen Iterator zu überladen, um zu inkrementieren, aber auf das folgende Element in der verknüpften Liste zu zeigen point?
Dieser Artikel erklärt das Überladen in C++. Es ist in zwei Teile unterteilt: Funktionsüberladung und Operatorüberladung. Um den Rest des Artikels zu verstehen, sind bereits Grundkenntnisse in C++ erforderlich.
Artikelinhalt
- Funktionsüberlastung
- Bedienerüberlastung
- Beispiel für das Überladen von String-Klassenoperatoren
- Iterator-Operator-Überladung
- Fazit
Funktionsüberlastung
Die folgende Funktion fügt zwei Ints hinzu und gibt ein Int zurück:
int add(int no1, int no2)int summe = no1 + no2;
Rücksendesumme;
Der Prototyp dieser Funktion ist:
int add(int no1, int no2);
Der Prototyp einer Funktion im Header der Funktion, der mit einem Semikolon endet. Die folgende Funktion mit demselben Namen, aber mit einem anderen Prototyp würde drei Floats hinzufügen und einen Float zurückgeben:
float add(float no1, float no2, float no3)
Gleitkommasumme = no1 + no2 + no3;
Rücksendesumme;
Wie unterscheidet der Compiler, welche Funktion aufgerufen werden soll, da zwei oder mehr Funktionen denselben Namen haben?? Der Compiler verwendet die Anzahl der Argumente und Argumenttypen, um zu bestimmen, welche Funktion aufgerufen werden soll. Die Parameterliste überladener Funktionen sollte sich in Anzahl und/oder Parametertypen unterscheiden differ. Also der Funktionsaufruf,
int sm = add(2, 3);würde die Integer-Funktion aufrufen, während der Funktionsaufruf,
float sme = add(2.3, 3.4, 2.0);würde die float-Funktion aufrufen. Hinweis: Es gibt Situationen, in denen der Compiler eine überladene Funktion ablehnt, wenn die Anzahl der Argumente gleich, aber unterschiedlichen Typs ist! - Grund: - siehe später.
Das folgende Programm setzt die obigen Codesegmente in Aktion:
#einschließenVerwenden von Namespace-Std;
int add(int no1, int no2)
int summe = no1 + no2;
Rücksendesumme;
float add(float no1, float no2, float no3)
Gleitkommasumme = no1 + no2 + no3;
Rücksendesumme;
int main()
int sm = add(2, 3);
cout<
cout<
Die Ausgabe ist:
5
7.7
Bedienerüberlastung Operator
Arithmetische Operatoren werden verwendet, um Operationen in Klassentypen zu überladen. Ein Iterator ist ein Klassentyp. Die Operatoren Inkrement und Dekrement werden verwendet, um Operationen für einen Iterator zu überladen.
Beispiel für das Überladen von String-Klassenoperatoren
Dieser Abschnitt enthält ein Beispiel, in dem + für eine einfach entworfene String-Klasse, die als Spring-Klasse bezeichnet wird, überladen ist. + verkettet die Literale zweier String-Objekte und gibt ein neues Objekt mit den verketteten Literalen zurück. Zwei Literale zu verketten bedeutet, das zweite Literal mit dem Ende des ersten Literals zu verbinden.
C++ hat jetzt eine spezielle Memberfunktion für alle Klassen, den sogenannten Operator. Der Programmierer kann diese spezielle Funktion verwenden, um Operatoren zu überladen, wie z +. Das folgende Programm zeigt die Überladung des Operators + für zwei Strings.
#einschließenVerwenden von Namespace-Std;
Klasse Frühling
Öffentlichkeit:
//Datenelemente
Zeichenwert[100];
int n;
Zeichenkonkat[100];
//Mitgliedsfunktionen
Frühling (char arr[])
für (int i=0; i<100; ++i)
val[i] = arr[i];
if (arr[i] == '\0')
Unterbrechung;
int ich;
für (i=0; i<100; ++i) if (arr[i] == '\0') break;
n = ich;
Federoperator+(spring& st)
int newLen = n + st.n;
char newStr[newLen+1];
für (int i=0; i
Frühling obj(newStr);
Rückgabeobjekt;
;
int main()
char ch1[] = "Ich hasse dich! "; Feder str1(ch1);
char ch2[] = "Aber sie liebt dich!"; Feder str2(ch2);
char ch3[] = "eins"; Feder str3(ch3);
Str3 = Str1 + Str2;
cout<
Der Wert von str1 ist "Ich hasse dich! ". Der Wert von str2 ist "Aber sie liebt dich!". Der Wert von str3, also str1 + str2, ist die Ausgabe:
"Ich hasse dich! Aber sie liebt dich!"
das ist die Verkettung der beiden String-Literale. Die Strings selbst sind instanziierte Objekte.
Die Definition der Operatorfunktion befindet sich in der Beschreibung (Definition) der String-Klasse. Es beginnt mit dem Rückgabetyp "spring" für "string". Der Sondername "Operator, folge diesem". Danach folgt das Symbol des Operators (zu überladen). Dann gibt es die Parameterliste, die eigentlich die Operandenliste ist. + ist ein binärer Operator: Das heißt, er benötigt einen linken und einen rechten Operanden. Nach der C++-Spezifikation enthält die Parameterliste hier jedoch nur die richtigen Parameter. Dann gibt es den Rumpf der Operatorfunktion, der das normale Operatorverhalten nachahmt.
Gemäß der C++-Spezifikation nimmt die Operatordefinition + nur den rechten Operandenparameter an, da der Rest der Klassenbeschreibung der linke Operandenparameter ist.
Im obigen Code befasst sich nur die Funktionsdefinition operator+() mit der + Überladung. Der Rest des Codes für die Klasse ist normale Codierung. Innerhalb dieser Definition werden die beiden String-Literale zu dem Array newStr[] verkettet. Danach wird tatsächlich ein neues String-Objekt erstellt (instanziiert), mit einem Argument, newStr[]. Am Ende der Funktionsdefinition operator+() wird das neu erstellte Objekt mit dem verketteten String zurückgegeben.
In der Funktion main() erfolgt die Addition durch die Anweisung:
Str3 = Str1 + Str2;Wobei str1, str2 und str3 String-Objekte sind, die bereits in main() erstellt wurden. Der Ausdruck „str1 + str2“ mit seinem + ruft die Memberfunktion operator+() im Objekt str1 auf. Die Memberfunktion operator+() im str1-Objekt verwendet str2 als Argument und gibt das neue Objekt mit (entwickelt) der verketteten Zeichenfolge zurück. Der Zuweisungsoperator (=) der vollständigen Anweisung ersetzt den Inhalt (Werte von Variablen) des str3-Objekts mit denen des zurückgegebenen Objekts. In der Funktion main() wird nach der Addition der Wert des Datenelements str3.val ist nicht mehr "eins"; es ist die verkettete (ergänzende) Zeichenfolge „Ich hasse dich! Aber sie liebt dich!". Die Memberfunktion operator+() im str1-Objekt verwendet das String-Literal seines eigenen Objekts und das String-Literal seines Arguments str2, um ein verbundenes String-Literal zu erstellen.
Iterator-Operator-Überladung
Beim Umgang mit dem Iterator sind mindestens zwei Objekte beteiligt: eine verknüpfte Liste und der Iterator selbst. Tatsächlich sind mindestens zwei Klassen beteiligt: eine Klasse, aus der eine verknüpfte Liste instanziiert wird, und eine Klasse, aus der ein Iterator instanziiert wird.
Verlinkte Liste
Ein Diagramm für ein doppelt verknüpftes Listenobjekt ist:
Diese Liste hat drei Elemente, aber es können noch mehr sein. Die drei Elemente hier sind Elemente von ganzen Zahlen. Der erste hat den Wert 14; der nächste hat den Wert 88; und der letzte hat den Wert 47. Jedes Element besteht hier aus drei aufeinanderfolgenden Orten.
Dies ist anders als beim Array, bei dem jedes Element an einem Ort ist und sich alle Array-Elemente an aufeinanderfolgenden Orten befinden. Hier befinden sich die verschiedenen Elemente an unterschiedlichen Stellen in der Speicherreihe, aber jedes Element besteht aus drei aufeinanderfolgenden Stellen.
Für jedes Element enthält die mittlere Position den Wert. Der richtige Ort hat den Zeiger auf das nächste Element. Die linke Position hat den Zeiger auf das vorherige Element. Beim letzten Element weist die richtige Position auf ein theoretisches Ende der Liste. Beim ersten Element weist die linke Stelle auf einen theoretischen Anfang der Liste.
Beim Array inkrementiert der Inkrement-Operator (++) den Zeiger, um auf die physisch nächste Position zu zeigen. Bei der Liste befinden sich die Elemente nicht in aufeinanderfolgenden Regionen im Speicher. So kann der Inkrement-Operator überladen werden, bewegen Sie den Iterator (Zeiger) von einem Element zum logisch nächsten Element. Die gleiche Projektion gilt für den Dekrementoperator (-).
Ein Vorwärts-Iterator ist ein Iterator, der bei Aktivierung auf das nächste Element zeigt. Ein umgekehrter Iterator ist ein Iterator, der, wenn er aktiviert ist, auf das vorherige Element zeigt.
++ Anzeige überladen -
Das Überladen dieser Operatoren erfolgt in der Klassenbeschreibung (Definition) des Iterators.
Die Syntax für den Prototyp der Überladung des Inkrementoperators, Präfix, ist
ReturnType-Operator++();Die Syntax für den Prototyp der Überladung des Inkrementoperators, postfix, ist
ReturnType-Operator++(int);Die Syntax für den Prototyp der Überladung des Dekrementoperators, Präfix, ist
ReturnType-Operator--();Die Syntax für den Prototyp der Überladung des Inkrementoperators, postfix, ist
ReturnType-Operator--(int);Fazit
Überladen bedeutet, einer Funktion oder einem Operator eine andere Bedeutung zu geben. Funktionen werden im gleichen Umfang überladen. Was überladene Funktionen unterscheidet, sind die Anzahl und/oder Arten von Parametern in ihren Parameterlisten. In einigen Fällen, in denen die Anzahl der Parameter gleich ist, aber mit unterschiedlichen Typen, lehnt der Compiler das Überladen ab - siehe später. Viele gewöhnliche Operatoren können in Klassen überladen werden, aus denen Objekte instanziiert werden. Dies geschieht, indem der speziellen Funktion namens operator in der Klassenbeschreibung ein Rückgabetyp, eine Parameterliste und ein Hauptteil übergeben werden.
