Passzeichenfolge durch Referenz in C ++ passieren

Die C ++ - Referenz ist ein Name für eine bereits vorhandene Variable. Eine Verweise auf eine Variable kann nicht geändert werden, um sich nach der Initialisierung auf die andere Variable zu beziehen. Zeiger oder Referenzen können als Parameter an Funktionen in C übergeben werden++. Somit ist das Ergebnis unter beiden Umständen identisch. Durch das Passing -By -Referenz kann eine Funktion eine Variable aktualisieren, ohne eine Kopie zu erstellen. Wir müssen Referenzvariablen deklarieren, damit der Parameter und die Variable übergeben werden, um denselben Speicherort zu teilen. Alle im Parameter auftretenden Änderungen beeinflussen auch die Variable.

Mit Hilfe von Beispielen werden wir den C ++ - Passieren von Referenzansatz und die Bereitstellung von Zeigern als Argumente für Funktionen in diesem Artikel verstehen. Die an die Funktionen als Zeiger übergebenen Parameter sind bei der Übergabe eines Wertes durch Referenz die gleichen wie bei jedem anderen Wert. Infolgedessen müssen Sie Zeigertypen für die Funktionsargumente angeben, wie in der Funktion SWAP (), die die Werte verschiedener ganzzahliger Variablen aus ihren Argumenten ausgetauscht haben.

Beispiel 1: Programm des Passierens von Referenz ohne Zeiger in C++

Hier vergeben wir einen Wert durch Referenz, ohne die Zeigererklärung zu verwenden. Unten finden Sie das Illustrationsprogramm für die Übergabe einer Variablen durch Referenz.

Zunächst haben wir die Header -Dateien für die Programmimplementierung in den Abschnitt Header aufgenommen. Im nächsten Schritt haben wir eine Funktionsdefinition für den Austausch von Werten. Die Funktion erhält einen Namenswechsel, und die Funktion nimmt zwei String -Variablenreferenzen als Parameter vor. Die Zeichenfolgevariablen Die Swap -Funktion wird als Referenzzeichen „STR1“ und „Str2“ definiert.

In der Funktion haben wir dann eine Variable „Temperatur“ erstellt, die wir die Variable „str1“ übergeben haben. Danach ist der „Str2“ „Str1“ zugeordnet, und dann hat „Str2“ das „str2“. Auf diese Weise wird der SWAP -Algorithmus auf die Referenzzeichenfolge angewendet.

Wir haben unsere Hauptfunktion, bei der zwei Zeichenfolgen als "str_a" und "str_b" deklariert und mit einigen Stringwerten initialisiert werden. Die Zeichenfolgewerte werden gedruckt, bevor die Swap -Funktion angewendet wird. Dann haben wir die Swap -Funktion in der Hauptfunktion aufgerufen und die in der Hauptfunktion definierte Zeichenfolge übergeben. Danach wird die ausgetauschte Schnur gedruckt.

#enthalten
Verwenden von Namespace STD;
void Swap (String & Str1, String & Str2)
String -Temperatur;
temp = str1;
str1 = str2;
str2 = temp;

int main ()

String str_a = "C ++", str_b = "Programmierung";
Cout<< "Strings Before swapping" <Cout<< "string 1 : " <Cout<< "String 2 : " <Swap (str_a, str_b);
Cout<< "\nStrings After swapping" <Cout<< "string 1 : " <Cout<< "string 2 : " <Rückkehr 0;

Das Ergebnis zeigt die Zeichenfolge vor dem Austausch und nach dem Austausch der in der Funktion übergebenen Referenzzeichenfolge.

Beispiel 2: Programm des Passierens von Referenz mit Zeigern in C++

Wie im vorhergehenden Beispiel haben wir nur die Passzeichenfolge durch Bezugnahme gesehen. Daher werden wir in diesem Beispiel Zeiger durch Referenz in C ++ verwenden.

Das Programm beginnt mit dem Erstellen einer Funktion, die mit dem Namen „SwapString“ dargestellt wird und als Argument an zwei Zeiger bestehen. Dann haben wir die Hauptfunktion des Programms bezeichnet. In der Hauptfunktion werden die beiden Saiten als „str1“ bzw. „str2“ bezeichnet. Diese Zeichenfolgevariablen werden mit der Zeichenfolge initialisiert.

Dann haben wir die Funktion als "SwapSstring" bezeichnet, an die die Zeichenfolge "Str1" und "Str2" -Azungen übergeben werden. Die Zeichenfolgen werden in dieser Funktionsdefinition in der Hauptfunktion ausgetauscht und gedruckt. Danach haben wir die Funktion als "SwapSstraße" außerhalb der Hauptfunktion zum Austausch der angegebenen Zeichenfolgen bezeichnet.

#enthalten
Verwenden von Namespace STD;
void swapString (String*, String*);
int main ()

String str1 = "Hallo", str2 = "Freunde";
Cout<< "Strings Before swapping" <Cout<< "Str1 = " << str1 <Cout<< "Str2 = " << str2<SwapString (& str1, & str2);
Cout<< "\nStrings After swapping" <Cout<< "str1 = " << str1 <Cout<< "str2 = " << str2 <Rückkehr 0;

void swapstring (String* S1, String* S2)
String -Temperatur;
temp = *s1;
*S1 = *S2;
*s2 = temp;

Daher sind die Ergebnisse von Übergabe von String -Referenzen mit Zeigern in der folgenden Grafik gezeigt.

Beispiel 3: Programm des Übergebenes String -Objekt durch Bezugnahme in C++

Auch wenn eine Funktion das Quell -String -Objekt im aufrufenden Programm nicht ändern kann, ist die Übergabe von C ++ - String -Objekten über Referenz ziemlich weit verbreitet. Objekte sind normalerweise ziemlich groß, und daher kann es im Vergleich zu der von ihnen verwendeten Speicherung und der Zeit, die erforderlich ist, um einen Klon von ihnen zu erstellen, kostspielig sein, wenn sie nach Wert bestehen. Im Allgemeinen speichert das Übergeben von Objekten durch Referenz sowohl Speicher als auch Zeit.

Der einzige Nachteil des Übergebenes eines Objekts über Referenz ist, dass es das Quellobjekt ändern kann, das an die Funktion übergeben wurde. Das ist nicht gewünscht. Wenn wir ein Objekt in der Funktion nicht aktualisieren wollen, würden wir es vorziehen, es schwierig zu machen.

Wir haben eine Funktionsdefinition im folgenden Programm als „InputString“, an das wir die String -Referenz bestanden haben. Dann haben wir in der Hauptfunktion ein String -Objekt "MYSTR" deklariert, und die Objektzeichenfolge "MYSTR" enthält eine Zeichenfolge eines Wortes.

Danach haben wir "InputString" bezeichnet und dieses String -Objekt darin übergeben. Wir haben eine Funktionsdefinition „inputString“ außerhalb der Hauptfunktion, die eine neue String -Objektreferenz aus dem „Mystr“ erstellt. Die neue Zeichenfolge ist definiert als „Newstr“ und dann im Körper der Funktion initialisiert. Wir haben die Objektzeichenfolge "Newstr" geändert und das neue String -Objekt gedruckt.

#enthalten
#enthalten
Verwenden von STD :: Cout;
mit std :: endl;
Verwenden von STD :: String;
void InputString (String &);
int main ()

String mystr = "Wel";
Cout<< "String value: " <InputString (MYSTR);
Cout<< "String value now :" <Rückkehr 0;

void InputString (String & Newstr)

Cout<< "String value in function :" <NewStr = NewStr + "Come";
Cout<< "String value now in function :" <

Die folgende Grafik repräsentiert die resultierenden Zeichenfolgewerte der Quellzeichenfolge und veränderte Zeichenfolge.

Beispiel 4: Programm der Übergabe eines konstanten String -Objekts durch Referenz in C++

Der Compiler wirft einen Fehler, wenn eine Referenz an das konstante Objekt übergeben wird. Wir können dieses Problem angehen, indem wir eine konstante variable Referenz verwenden. Dies verhindert die Variable, in die sich die Referenzpunkte verändert haben.

Zunächst haben wir die Funktionsdefinition „DisplayString“, wobei eine konstante Zeichenfolge übergeben wird. Die konstanten Zeichenfolgen werden in der Hauptfunktion definiert und initialisiert als „str1“ und „str2“. Übergeben Sie diese konstanten Zeichenfolgen anschließend an die Funktion „InputString“. Rief die Funktion außerhalb der Hauptfunktion auf, bei der wir eine konstante String -Variable "Mystr" deklariert haben.

#enthalten
#enthalten
Verwenden von STD :: Cout;
mit std :: endl;
Verwenden von STD :: String;
void displayString (const String &);
int main ()

const String str1 = "Infinix";
String str2 = "iPhone";
Cout<< "str1 :" << str1 <DisplayString (STR1);
Cout<< "str2 : " << str2 <DisplayString (str2);
Rückkehr 0;

void displaystring (const string & mystr)

Cout<< "MyStr : " <

Ein nicht konstantes Objekt wird durch eine konstante Objektreferenz an eine Funktion übergeben. Wir erhalten also keine Kompilierungsfehler im Code.

Abschluss

Referenzen ermöglichen es einer Funktion, den Wert eines Arguments zu beeinflussen, was in einigen Situationen von Vorteil sein kann. Const Referenzen dagegen stellen Sie sicher, dass die Funktion das Argument nicht ändert. Daher haben wir den Artikel hier mit der Beispieldemonstration in C ++ abgeschlossen und hoffen, dass er hilfreich sein könnte.