Call by Value: Unterschied zwischen den Versionen
Hauer (Diskussion | Beiträge) (Die Seite wurde neu angelegt: „Als '''Call by Value''' bezeichnet man den Mechanismus der Parameterübergabe von primitiven Datentypen. Sein Pendant ist der Mechanismus des [[Call by Referen…“) |
Hauer (Diskussion | Beiträge) (→Verwendung) |
||
Zeile 23: | Zeile 23: | ||
Was tatsächlich passiert ist, dass beim Aufruf einer Funktion ein neuer [[Stack#Stackframe | Stackframe]] für diesen Aufruf auf den [[Stack]] gelegt wird und die lokalen Parametervariablen innerhalb dieses Stackframes mit den übergebenen Werten initialisiert werden. Ein konstanter Aufruf von <code>callee(int a)</code> mit der Zahl 5 wäre also praktisch nicht zu unterscheiden von einer Methode, die folgendermaßen aussieht: | Was tatsächlich passiert ist, dass beim Aufruf einer Funktion ein neuer [[Stack#Stackframe | Stackframe]] für diesen Aufruf auf den [[Stack]] gelegt wird und die lokalen Parametervariablen innerhalb dieses Stackframes mit den übergebenen Werten initialisiert werden. Ein konstanter Aufruf von <code>callee(int a)</code> mit der Zahl 5 wäre also praktisch nicht zu unterscheiden von einer Methode, die folgendermaßen aussieht: | ||
− | < | + | <source lang="Java">public static callee(){ |
int a = 5; | int a = 5; | ||
a = a + 5; | a = a + 5; | ||
− | }</ | + | }</source> |
Version vom 14. Dezember 2015, 12:52 Uhr
Als Call by Value bezeichnet man den Mechanismus der Parameterübergabe von primitiven Datentypen. Sein Pendant ist der Mechanismus des Call by Reference.
Dabei wird beim Aufruf einer Funktion der Wert einer Variable zuerst aufgelöst und dann direkt an die aufrufende Methode übergeben. Da die Parameter einer Funktion lokal auf dem Stack der Methode liegen, sind diese unabhängig von denen, die beim Aufruf der Methode verwendet wurden. Änderungen an den Parametervariablen haben demnach keinen Einfluss auf die Werte der übergebenen Variablen innerhalb der aufrufenden Methode.
Verwendung
Immer, wenn eine Methode aufgerufen wird, werden übergebene Variablen zuerst aufgelöst und der resultierende Wert übergeben:
public static void caller(){ int i = 5; callee(i); } public static void callee(int a){ a = a + 5; }
Die Methode caller()
deklariert eine int
Variable i
mit dem Wert 5. Beim Aufruf von callee(int a)
wird die übergebene Variable i
nun zuerst zum Wert 5 aufgelöst. Dann wird die Funktion callee(int a)
mit dem Wert 5 aufgerufen. Der Aufruf callee(i)
ist also in diesem Falle nicht zu unterscheiden von einem Aufruf callee(5)
. Hier sieht man zudem den Grund für das Verhalten von Call by Value:
Wenn eine Funktion wie callee(int a)
direkt mit einem konstanten Wert, wie 5/code>, aufgerufen werden würde und Änderungen innerhalb der Methode Einfluss nach außen hätten, wie würde dieser Einfluss bei einem solchen Aufruf mit einer Konstanten wirken? Es wurde schließlich keine Variable als Repräsentation eines veränderbaren Wertes beim Aufruf übergeben, was also soll sich beim Aufruf ändern? Für diesen Fall gibt es keine Semantik, die Sinn ergeben würde.
Was tatsächlich passiert ist, dass beim Aufruf einer Funktion ein neuer Stackframe für diesen Aufruf auf den Stack gelegt wird und die lokalen Parametervariablen innerhalb dieses Stackframes mit den übergebenen Werten initialisiert werden. Ein konstanter Aufruf von <code>callee(int a) mit der Zahl 5 wäre also praktisch nicht zu unterscheiden von einer Methode, die folgendermaßen aussieht:
public static callee(){ int a = 5; a = a + 5; }