Überlastung in C ++

C ++ lässt keine Funktion zu, die zwei Ganzzahlen hinzufügt und eine Ganzzahl zurückgibt, zwei Schwimmkörper hinzufügt und einen Float zurückgibt. Stellen Sie sich vor, es gibt eine Funktion, um zwei ganze Zahlen hinzuzufügen und eine Ganzzahl zurückzugeben. Wäre es nicht schön, eine andere Funktion mit demselben Namen zu haben, der nur zwei oder sogar mehr Schwimmer hinzufügt, um einen Float zurückzugeben? Dies soll die erste Funktion überladen.

Arithmetische Operatoren werden typischerweise für arithmetische Operationen verwendet. Ist es nicht schön, die +zu haben, treten zwei Saiten bei? Das Aktivieren, das den arithmetischen Zusatzoperator für Zeichenfolgen überlastet, wird bezeichnet.

Der Inkrementoperator ++ fügt einem INT oder einem Float 1 hinzu. Beim Umgang mit Zeigern fügt es dem Zeiger nicht 1 hinzu. Es lässt den Zeiger auf das nächste aufeinanderfolgende Objekt im Speicher zeigen. Ein Iterator verweist auf das nächste Objekt in einer verknüpften List, aber die Objekte mit verknüpften Listen befinden sich an verschiedenen Stellen im Speicher (nicht in aufeinanderfolgenden Regionen). Wäre es nicht schön, den Inkrementoperator für einen Iterator zu überladen, zu erhöhen, aber auf das folgende Element in der verknüpften List zu verweisen?

Dieser Artikel erklärt Überladung in C++. Es ist in zwei Teile unterteilt: Funktion Überladen und Bedienerüberladung. Es ist notwendig, den Rest des Artikels zu verstehen.

Artikelinhalt

• Funktion Überlastung
• Bedienerüberlastung
• Beispiel für String -Klassen -Operator Überladen
• Überlastung des Iterator -Bedieners
• Abschluss

Funktion Überlastung

Die folgende Funktion fügt zwei INTs hinzu und gibt einen int zurück:

int add (int no1, int no2)

int sum = no1 + no2;
Rückgabesumme;

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, jedoch mit einem anderen Prototyp, würde drei Schwimmer hinzufügen und einen Float zurückgeben:

Float Add (Float No1, Float No2, Float No3)

float sum = NO1 + NO2 + NO3;
Rückgabesumme;

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 Argumententypen, um zu bestimmen, welche Funktion aufgerufen werden soll. Die Parameterliste der überlasteten Funktionen sollte sich in ihren Anzahl und/oder Parametertypen unterscheiden. Also den Funktionsaufruf,

int sm = add (2, 3);

würde die Ganzzahlfunktion 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 überlastete Funktion ablehnt, wenn die Anzahl der Argumente gleich ist, aber von verschiedenen Typen! - Grund: - Siehe später.

Das folgende Programm setzt die oben genannten Codesegmente in Aktion:

#enthalten
Verwenden von Namespace STD;
int add (int no1, int no2)

int sum = no1 + no2;
Rückgabesumme;

Float Add (Float No1, Float No2, Float No3)

float sum = NO1 + NO2 + NO3;
Rückgabesumme;

int main ()

int sm = add (2, 3);
Cout<Float SME = add (2.3, 3.4, 2.0);
Cout<Rückkehr 0;

Die Ausgabe ist:

5
7.7

Bedienerüberlastung

Arithmetische Operatoren werden verwendet, um Operationen in Klassentypen zu überlasten. Ein Iterator ist ein Klassentyp. Die Inkrement- und Decrement -Operatoren werden verwendet, um Operationen für einen Iterator zu überlasten.

Beispiel für String -Klassen -Operator Überladen

Dieser Abschnitt enthält ein Beispiel, in dem + für eine einfach entworfene String -Klasse, die als Frühlingsklasse bezeichnet wird. + verkettet die Literale zweier String -Objekte und gibt ein neues Objekt mit den verketteten Literalen zurück. Verkettung von zwei Literalen bedeutet bedeutet.

Jetzt hat C ++ eine spezielle Mitgliedsfunktion für alle Klassen, die als Operator bezeichnet wird. Der Programmierer kann diese spezielle Funktion verwenden, um Operatoren wie z +. Das folgende Programm zeigt die Überlastung des + Operators für zwei Zeichenfolgen.

#enthalten
Verwenden von Namespace STD;
Klassenfeder

öffentlich:
// Datenmitglieder
Char Val [100];
int n;
Char concat [100];
// Mitgliedsfunktionen
Feder (char arr [])

für (int i = 0; i<100; ++i)
val [i] = arr [i];
if (arr [i] == '\ 0')
brechen;

int i;
für (i = 0; i<100; ++i) if (arr[i] == '\0') break;
n = i;

Federoperator+(Spring & St)
int newlen = n + st.N;
Char Newstr [Newlen+1];
für (int i = 0; ifür (int i = n; ichNewStr [newlen] = '\ 0';
Spring OBJ (Newstr);
Rückkehr obj;

;
int main ()

char ch1 [] = "Ich hasse dich! "; Spring Str1 (CH1);
char ch2 [] = "Aber sie liebt dich!"; Spring Str2 (CH2);
char ch3 [] = "eins"; Spring Str3 (CH3);
str3 = str1 + str2;
Cout<Rückkehr 0;

Der Wert von str1 lautet: "Ich hasse dich! ". Der Wert von str2 lautet ", aber sie liebt dich!". Der Wert von str3, dh Str1 + str2, ist der Ausgang:

"Ich hasse dich! Aber sie liebt dich!"

Welches ist die Verkettung der beiden Streicherliterale. Die Saiten selbst sind instanziierte Objekte.

Die Definition der Operatorfunktion befindet sich in der Beschreibung (Definition) der String -Klasse. Es beginnt mit dem Rückkehrtyp "Spring" für "String". Der besondere Name "Operator, folge diesem". Danach gibt es das Symbol des Bedieners (überladen zu werden). Dann gibt es die Parameterliste, die tatsächlich die Operand -Liste ist. + ist ein binärer Operator: Das heißt, es dauert einen linken und einen rechten Operand. Nach der C ++ - Spezifikation hat die Parameterliste hier jedoch nur den richtigen Parameter. Dann gibt.

Nach der C ++ - Spezifikation nimmt die+ Operator -Definition nur den rechten Operandenparameter vor, da der Rest der Klassenbeschreibung der Parameter des linken Operanden ist.

Im obigen Code befasst sich nur die Funktionsdefinition von Operator + () mit der + Überlastung. Der Rest des Codes für die Klasse ist normale Codierung. In dieser Definition werden die beiden String -Literale in das Array, Newstr [], verkettet. Danach wird tatsächlich ein neues String -Objekt erstellt (instanziiert) mit einem Argument, NewStr []. Am Ende der Funktionsdefinition des Operators+() wird das neu erstellte Objekt mit der verketteten Zeichenfolge zurückgegeben.

In der Funktion main () erfolgt die Zugabe 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 Operator +() Mitgliedsfunktion im STR1 -Objekt auf. Die Operator+() -Mitlerfunktion im STR1 -Objekt verwendet Str2 als Argument und gibt das neue Objekt mit (entwickelt) der verketteten Zeichenfolge zurück. Der Zuordnungsoperator (=) der vollständigen Anweisung ersetzt den Inhalt (Werte von Variablen) des STR3 -Objekts durch die des zurückgegebenen Objekts. In der main () -Funktion nach Addition den Wert des Datenelements Str3.Val ist nicht mehr "eins"; Es ist die verkettete (Addition) String "Ich hasse dich! Aber sie liebt dich!". Die Operator+() Mitgliedsfunktion im STR1 -Objekt verwendet die Zeichenfolge des eigenen Objekts und die Saitenliteral seines Arguments STR2, um ein verbundenes String -Literal zu erstellen.

Überlastung des Iterator -Bedieners

Beim Umgang mit dem Iterator sind mindestens zwei Objekte beteiligt: ​​eine verknüpfte List und den 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.

Verbindungsliste

Ein Diagramm für ein doppelt verknüpftes Listenobjekt lautet:

Diese Liste hat drei Elemente, aber es kann mehr geben. Die drei Elemente hier sind Elemente von Ganzzahlen. Der erste hat den Wert, 14; Der nächste hat den Wert, 88; und der letzte hat den Wert, 47. Jedes Element hier besteht aus drei aufeinanderfolgenden Standorten.

Dies ist anders als das Array, wobei jedes Element ein Ort ist und alle Array -Elemente an aufeinanderfolgenden Orten liegen. Hier befinden sich die verschiedenen Elemente an verschiedenen Stellen in der Speicherreihe, aber jedes Element besteht aus drei aufeinanderfolgenden Standorten.

Für jedes Element enthält der mittlere Standort den Wert. Der richtige Ort hat den Zeiger auf das nächste Element. Der linke Ort hat den Zeiger auf das vorherige Element. Für das letzte Element verweist der richtige Ort auf ein theoretisches Ende der Liste. Für das erste Element verweist der linke Ort auf einen theoretischen Start der Liste.

Mit dem Array, dem Inkrementoperator (++), erhöht der Zeiger auf den physischen nächsten Ort. Mit der Liste befinden sich die Elemente nicht in aufeinanderfolgenden Regionen im Gedächtnis. Daher kann der Inkrementoperator überlastet werden, verschieben Sie den Iterator (Zeiger) von einem Element in das logischste nächste Element. Die gleiche Projektion gilt für den Dekrementbetreiber (-).

Ein Vorwärts -Iterator ist ein Iterator, der beim Einsatz auf das nächste Element zeigt. Ein umgekehrter Iterator ist ein Iterator, der beim Einsatz auf das vorherige Element zeigt.

Überladung ++ Anzeige -

Die Überlastung dieser Operatoren erfolgt in der Klassenbeschreibung (Definition) des Iterators.

Die Syntax für den Prototyp des Überladens des Inkrement -Operators, Präfix, ist

RETURSCHENDEMTER OPERATOR ++ ();

Die Syntax für den Prototyp des Überladens des Inkrement -Operators, Postfix, ist

RETURSCHENDEMTER OPERATOR ++ (INT);

Die Syntax für den Prototyp der Überlastung des Decrement -Operators, Präfix, ist

Returnype Operator-();

Die Syntax für den Prototyp des Überladens des Inkrement -Operators, Postfix, ist

Return-Typ-Operator-(int);

Abschluss

Überladung bedeutet, einer Funktion oder einem Operator eine andere Bedeutung zu geben. Funktionen sind im selben Bereich überladen. Was überlastete Funktionen unterscheidet, sind die Anzahl und/oder die 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 die Überladung ab - siehe später. Viele gewöhnliche Operatoren können in Klassen überladen werden, aus denen Objekte instanziiert werden. Dies erfolgt durch eine Rückgabetyp, eine Parameterliste und einen Körper für die spezielle Funktion namens Operator in der Klassenbeschreibung.