C++ ist eine flexible Allzweck-Programmiersprache. Es wurde ursprünglich erstellt von Bjarne Stroustrup, ein dänischer Informatiker, 1985. C++ unterstützt Drei-Parameter-Übergabemethoden, d. h. Aufruf nach Wert, Aufruf nach Adresse und Aufruf nach Referenz. In diesem Artikel werden wir über Call-by-Address- und Call-by-Reference-Mechanismen sprechen.
Was ist eine Funktion?
Bevor wir in das eigentliche Thema einsteigen, müssen wir verstehen, was die Funktion in C++ ist. Viele von Ihnen kennen die Funktionen vielleicht schon.
Eine Funktion ist im Grunde ein Stück Code, das verwendet werden kann, um eine bestimmte Aufgabe auszuführen. Eine Funktion wird hauptsächlich verwendet, um den sich wiederholenden Code in einem C++-Programm zu reduzieren. Es nimmt Eingaben als Parameter an und gibt die Ausgabe als Rückgabewert zurück. Wenn wir die Funktion einmal definieren, können wir sie im späteren Teil unseres Programms mehrmals aufrufen/verwenden. Auf diese Weise sparen wir viel sich wiederholenden Code im Programm.
Jedes C++ Programm soll die main() Funktion haben. Die Funktion main() ist der Einstiegspunkt für ein C++-Programm. Abgesehen von der main()-Funktion kann der Programmierer beliebig viele Funktionen definieren.
Hier ist die Syntax zum Definieren einer Funktion:
Rückgabetyp Funktionsname(Eingabeparameterliste)
Eine Funktion in C++ kann 0 oder mehr Eingabeparameter akzeptieren, während sie nur einen Rückgabewert zurückgeben kann.
Was ist Adresse?
Es gibt zwei Arten von Variablen in C++ (ähnlich der Sprache C) – Datenvariable und Adressvariable. Die Adressvariable wird verwendet, um die Adresse einer anderen Datenvariablen zu speichern. Betrachten wir zum Beispiel das folgende Code-Snippet:
intich= 100;
int *ptr= &ich;
Hier sagt uns die erste Anweisung, dass die Variable i eine Datenvariable ist und den Wert 100 speichert. In der zweiten Anweisung deklarieren wir eine Zeigervariable, d. h. ptr, und initialisieren sie mit der Adresse der Variablen i.
Was ist Referenz?
Die Referenz ist ein weiteres leistungsstarkes Feature der C++-Sprache. Betrachten wir das folgende Code-Snippet:
intzu= 200;int &R=zu;
In diesem Beispiel haben wir eine ganze Zahl, also a, deklariert und dann eine Referenzvariable r deklariert, die mit dem Wert von a initialisiert wird. Die Referenzvariable ist also nichts anderes als ein Alias einer anderen Variablen.
Methoden zur Parameterübergabe:
In der Sprache C++ gibt es drei Arten von Methoden zur Parameterübergabe:
- Anruf nach Wert / Wertübergabe
- Nach Adresse anrufen / Nach Adresse weitergeben
- Call by Reference / Pass by Reference
In diesem Artikel diskutieren wir über die – Call by address und Call by reference.
Was ist Call-by-Address / Pass-by-Adresse?
Bei der Methode Call by address / Pass by address werden die Funktionsargumente als Adresse übergeben. Die Aufruferfunktion übergibt die Adresse der Parameter. Zeigervariablen werden in der Funktionsdefinition verwendet. Mit Hilfe der Methode Call by address kann die Funktion auf die Aktualparameter zugreifen und diese ändern. Wir werden später in diesem Artikel ein Beispiel für die Methode Call by address sehen.
Was ist Call-by-Reference / Pass-by-Reference?
In der Methode Call by reference / Pass by reference werden die Funktionsparameter als Referenz übergeben. Innerhalb der Funktionsdefinition wird über die Referenzvariable auf die Aktualparameter zugegriffen.
Beispiele:
Da wir nun das Konzept der Parameterübergabemethoden verstehen, werden wir mehrere Beispielprogramme sehen, um den Parameterübergabemechanismus in C++ zu verstehen:
- Beispiel-1 – Anruf über Adresse (1)
- Beispiel-2 – Anruf über Adresse (2)
- Beispiel-3 – Aufruf nach Referenz (1)
- Beispiel-4 – Aufruf nach Referenz (2)
Die ersten beiden Beispiele werden gegeben, um zu erklären, wie die Methode Call by address in C++ funktioniert. Die letzten beiden Beispiele sollen das Call-by-Reference-Konzept erläutern.
Beispiel-1 – Anruf über Adresse (1)
In diesem Beispiel demonstrieren wir den Call-by-Address-Mechanismus. Von der main()-Funktion rufen wir die hello()-Funktion auf und übergeben die Adresse von var. In der Funktionsdefinition erhalten wir die Adresse von var in einer Zeigervariablen, also p. Innerhalb der Funktion hello wird der Wert von var mit Hilfe des Zeigers auf 200 geändert. Daher wird der Wert von var in der main()-Funktion nach dem hello()-Funktionsaufruf auf 200 geändert.
#enthaltenmit Namensraumstd;
LeereHallo(int *P)
{
Kosten <<endl<< 'In der hallo()-Funktion: ' <<endl;
Kosten << 'Wert von *p = ' << *P<<endl;
*P= 200;
Kosten << 'Wert von *p = ' << *P<<endl;
Kosten << 'Hallo()-Funktion wird verlassen.' <<endl;
}
inthauptsächlich()
{
intwo= 100;
Kosten << 'Wert von var innerhalb der Funktion main() = ' <<wo<<endl;
Hallo(&wo);
Kosten <<endl<< 'Wert von var innerhalb der Funktion main() = ' <<wo<<endl;
Rückkehr 0;
}
Beispiel-2 – Anruf über Adresse (2)
Dies ist ein weiteres Beispiel für die Methode Call by Address. In diesem Beispiel werden wir erklären, wie die Call-by-Address-Methode verwendet werden kann, um ein reales Problem zu lösen. Zum Beispiel möchten wir eine Funktion schreiben, um zwei Variablen auszutauschen. Wenn wir den Call-by-Value-Mechanismus verwenden, um zwei Variablen auszutauschen, werden die tatsächlichen Variablen in der Aufruffunktion nicht ausgetauscht. In einem solchen Szenario kann die Call-by-Address-Methode verwendet werden. In diesem Beispiel übergeben wir die Adresse von var_1 (&var_1) und var_2 (&var_2) an die Funktion mySwap(). Innerhalb der Funktion mySwap() tauschen wir die Werte dieser beiden Variablen mit Hilfe der Zeiger aus. Wie Sie in der folgenden Ausgabe sehen können, wird der tatsächliche Wert dieser Variablen in der main()-Funktion getauscht, nachdem die mySwap()-Funktion ausgeführt wurde.
#enthaltenmit Namensraumstd;
LeeremySwap(int *vptr_1,int *vptr_2)
{
inttemp_var;
temp_var= *vptr_1;
*vptr_1= *vptr_2;
*vptr_2=temp_var;
}
inthauptsächlich()
{
intvar_1= 100;
intvar_2= 300;
Kosten << 'Vor Aufruf der Funktion mySwap(), Wert von var_1 : ' <<var_1<<endl;
Kosten << 'Vor dem Aufruf der Funktion mySwap(), Wert von var_2 : ' <<var_2<<endl<<endl;
Kosten << 'Aufruf der Funktion mySwap() - Aufruf nach Adresse.' <<endl<<endl;
mySwap(&var_1,&var_2);
Kosten << 'Nach Aufruf der Funktion mySwap(), Wert von var_1 : ' <<var_1<<endl;
Kosten << 'Nach Aufruf der Funktion mySwap(), Wert von var_2 : ' <<var_2<<endl;
Rückkehr 0;
}
Beispiel-3 – Aufruf nach Referenz (1)
In diesem Beispiel werden wir demonstrieren, wie Call-by-Reference in C++ funktioniert. In der Funktionsdefinition hello() wird der Wert als Referenzvariable (&p) empfangen. Mit Hilfe der Referenzvariablen (d. h. p) können wir den Wert des Aktualparameters (var) innerhalb der main()-Funktion ändern.
#enthaltenmit Namensraumstd;
LeereHallo(int &P)
{
Kosten <<endl<< 'In der hallo()-Funktion: ' <<endl;
Kosten << 'Wert von p = ' <<P<<endl;
P= 200;
Kosten << 'Wert von p = ' <<P<<endl;
Kosten << 'Hallo()-Funktion wird verlassen.' <<endl;
}
inthauptsächlich()
{
intwo= 100;
Kosten << 'Wert von var innerhalb der Funktion main() = ' <<wo<<endl;
Hallo(wo);
Kosten <<endl<< 'Wert von var innerhalb der Funktion main() = ' <<wo<<endl;
Rückkehr 0;
}
Beispiel-4 – Aufruf nach Referenz(2)
Dies ist ein weiteres Beispiel für einen Aufruf per Referenz. In diesem Beispiel demonstrieren wir anhand eines realen Beispiels, wie Call-by-Reference in C++ funktioniert. Die mySwap()-Funktion wird von der main()-Funktion mit den folgenden Parametern aufgerufen – var_1 und var_2. Innerhalb der Funktion mySwap() erhalten wir die Parameter als Referenzvariablen.
#enthaltenmit Namensraumstd;
LeeremySwap(int &vref_1,int &vref_2)
{
inttemp_var;
temp_var=vref_1;
vref_1=vref_2;
vref_2=temp_var;
}
inthauptsächlich()
{
intvar_1= 100;
intvar_2= 300;
Kosten << 'Vor Aufruf der Funktion mySwap(), Wert von var_1 : ' <<var_1<<endl;
Kosten << 'Vor dem Aufruf der Funktion mySwap(), Wert von var_2 : ' <<var_2<<endl<<endl;
Kosten << 'Aufruf der Funktion mySwap() - Aufruf nach Referenz.' <<endl<<endl;
mySwap(var_1, var_2);
Kosten << 'Nach Aufruf der Funktion mySwap(), Wert von var_1 : ' <<var_1<<endl;
Kosten << 'Nach Aufruf der Funktion mySwap(), Wert von var_2 : ' <<var_2<<endl;
Rückkehr 0;
}
Abschluss
Verstehen der Parameterübergabemethoden in C++ ist sehr entscheidend. Die Programmiersprache C unterstützt nur Call by value und Call by address. C++ unterstützt jedoch Call by Reference zusammen mit den beiden vorherigen Mechanismen. In diesem Artikel haben wir mehrere Arbeitsbeispiele gesehen, um das Konzept von Call by Address und Call by Reference zu verstehen. Call by Address ist eine sehr leistungsfähige und beliebte Methode in eingebetteten Domänenanwendungen.