Vergleichstabelle:
| Vergleichsgrundlage | Call_By_Value | Anruf per Referenz |
|---|---|---|
| Basic | Eine Kopie der Variablen wird übergeben. | Eine Variable selbst wird übergeben. |
| Bewirken | Die Änderung einer Kopie der Variablen ändert den ursprünglichen Wert der Variablen außerhalb der Funktion nicht. | Die Änderung der Variablen wirkt sich auch auf den Wert der Variablen außerhalb der Funktion aus. |
| Aufrufparameter | Funktionsname (Variablenname1, Variablenname2, ....); | Funktionsname (& Variablenname1, & Variablenname2, ...); // im Falle eines Objekts object.func_name (object); |
| Empfangsparameter | Typ Funktionsname (Typ Variablenname1, Typ Variablenname2, ....) {. . } | Typ Funktionsname (Typ * Variablenname1, Typ * Variablenname2, ....). {. . } // im Falle eines Objekts Typ Funktionsname (Klassentyp Objektname) {. . } |
| Standardaufruf | Primitivtyp wird mit "call by value" übergeben. | Objekte werden implizit mit "call by reference" übergeben. |
Definition des Anrufs nach Wert
Wenn Sie einen primitiven Datentyp (Ganzzahl, Zeichen und String) an eine Funktion / Methode übergeben, wird nur der „Wert“ an den Funktionscode übergeben. Die Funktion kopiert diesen Wert eines Arguments in einen 'Formalparameter' des Funktionscodes. Wenn der formale Parameter in einem Funktionscode geändert wird, wird der ursprüngliche Wert des Arguments, das zum Aufruf dieser Funktion verwendet wird, nicht geändert.
In einfachen Worten, wenn eine Funktion / Methode durch den Aufruf von call by value aufgerufen wird; Dann wird eine Kopie der Variablen an den Funktionscode übergeben. Wenn ein Funktionscode Änderungen an dem Wert in der Kopie der Variablen vornimmt, ändert er den ursprünglichen Wert der Variablen nicht.
Sehen wir uns ein Beispiel an, um dies kurz zu verstehen.
// Beispiel bei der Java-Klassenprüfung {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("Wert des Parameters innerhalb der Funktion"); system.out.println ("Wert von 'i', der den Wert von Argument 'a' akzeptiert" + i); system.out.println ("Wert von 'j', der den Wert von Argument 'b' akzeptiert" + j); }} class call_by _value {public static void main (Zeichenfolge args []) {int a = 12, b = 20; check C = new check (); system.out.println ("Wert von 'a' und 'b' vor dem Funktionsaufruf" + a + "" + b); C.ändern (a, b); // Aufruf mit Wert. system.out.println ("Wert von 'a' und 'b' nach Funktionsaufruf" + a + "" + b); }} // Ausgabewert von 'a' und 'b' vor dem Funktionsaufruf 12 20 Wert des Parameters innerhalb des Funktionswerts von 'i', der den Wert des Arguments 'a' 144 akzeptiert, der den Wert von 'j' akzeptiert Argument 'b' 10 Wert von 'a' und 'b' nach dem Funktionsaufruf 12 20 Definition des Anrufs als Referenz
Call by Reference-Methode übergibt eine Referenz / Adresse eines Arguments an den Funktionscode. Wenn die Adresse eines Arguments an den Funktionscode übergeben wird, wäre der formale Parameter, der diese Adresse akzeptiert, eine 'Zeiger'-Variable. Wenn nun der Funktionscode die Adresse eines Arguments erhalten hat, ändert die Änderung des Werts eines Arguments auch den ursprünglichen Wert eines Arguments.
In C ++ und Java ist es üblich, das Objekt an die Funktion / Methode zu übergeben, und das Objekt wird immer anhand seiner Referenz übergeben. Änderungen an dem Objekt innerhalb der Funktion / Methode wirken sich auf das Objekt aus, das zum Aufrufen dieser Funktion / Methode verwendet wird.
Das folgende Fragment zeigt den richtigen Weg zum 'Aufruf durch Verweis'.
// Beispiel in der C ++ - Klasse swap {void swap (int * x, int * y) {int temp; Temp = * x; * x = * y; * Y = Temp; }} int main {int a = 10, b = 20; cout << "Wert von a, b vor dem Funktionsaufruf" << a << "" < Lassen Sie uns nun 'Aufruf durch Verweis' diskutieren, indem Sie ein 'Objekt' als Argument übergeben, das implizit durch den Ansatz 'Aufruf durch Verweis' übergeben wird.
Klassenprüfung {int a, b; check (int x, int b) {// Objekt, das durch diesen Konstruktor initialisiert wurde a = x; b = y; } void exchange (check ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {public static void main (Zeichenfolge args []) {check C = new check (20, 40); // Objektinitialisierung. system.out.println ("Wert von 'ob.a' und 'ob.b' vor dem Funktionsaufruf" + ob.a + "" + ob.b); C. Austausch (C); // Aufruf per Referenz. system.out.println ("Wert von 'ob.a' und 'ob.b' vor dem Funktionsaufruf" + ob.a + "" + ob.b); }} // Ausgabewert von 'ob.a' und 'ob.b' vor dem Funktionsaufruf 20 40 Wert von 'ob.a' und 'ob.b' nach dem Funktionsaufruf 40 20 Hauptunterschiede zwischen Anruf nach Wert und Anruf nach Referenz
- Beim Übergeben des Arguments mit der Methode "Aufruf nach Wert" wird nur die Kopie dieser Variablen übergeben. Änderungen des Werts in der Kopie dieser Variablen wirken sich daher nicht auf den ursprünglichen Wert dieser Variablen aus. Bei der Methode "Aufruf durch Referenz" wird die Variable selbst als Argument übergeben, daher ändern Änderungen daran den Wert der ursprünglichen Variablen.
- Wenn es sich bei den übergebenen Argumenten um primitive Datentypen handelt, werden sie einfach 'call by value' aufgerufen. Wenn jedoch die Referenzen / Adressen der Argumente oder Objekte übergeben werden, wird eine Funktion mit der 'call by reference'-Methode aufgerufen.
- Bei 'Call by Value-Ansatz' sind die übergebenen Argumente nur der Name von Variablen, wohingegen beim 'Call by Reference'-Ansatz die übergebenen Argumente Variablenname entlang des' & '- Zeichens oder ein Objekt sind, das nur durch seinen Namen übergeben wird.
- Empfangsparameter des Arguments in der Methode "Aufruf nach Wert" sind der Variablenname und sein Datentyp. Beim 'Aufruf durch Referenz'-Ansatz ist der empfangende Parameter zusammen mit dem Datentyp immer eine Zeigervariable und im Fall eines Objekts ein Objektname mit seinem Klassentyp.
Fazit:
C ++ und Java verwenden beide Ansätze, je nachdem, was übergeben wird. Wenn Sie nur den Wert der Variablen use'call by value 'übergeben möchten und die Änderung des ursprünglichen Werts der Variablen sehen möchten, verwenden Sie die Methode' call by reference '.
