Call by Value: Unterschied zwischen den Versionen
Hauer (Diskussion | Beiträge) (→Verwendung) |
K |
||
| Zeile 1: | Zeile 1: | ||
Als '''Call by Value''' bezeichnet man den Mechanismus der Parameterübergabe von primitiven Datentypen. Sein Pendant ist der Mechanismus des [[Call by Reference]]. | 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. | + | 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 [[Parametervariable|Parametervariablen]] haben demnach keinen Einfluss auf die Werte der übergebenen Variablen innerhalb der aufrufenden Methode. |
= Verwendung = | = Verwendung = | ||
| − | Immer | + | Immer wenn eine Methode aufgerufen wird, werden übergebene Variablen zuerst aufgelöst und dann der resultierende Wert übergeben. Nehmen wir als Beispiel folgende zwei [[static | statische]] Methoden: |
<source lang="Java"> | <source lang="Java"> | ||
public static void caller(){ | public static void caller(){ | ||
| Zeile 18: | Zeile 18: | ||
Die Methode <code>caller()</code> deklariert eine <code>int</code> Variable <code>i</code> mit dem Wert 5. Beim Aufruf von <code>callee(int a)</code> wird die übergebene Variable <code>i</code> nun zuerst zum Wert 5 aufgelöst. Dann wird die Funktion <code>callee(int a)</code> mit dem Wert 5 aufgerufen. Der Aufruf <code>callee(i)</code> ist also in diesem Falle nicht zu unterscheiden von einem Aufruf <code>callee(5)</code>. Hier sieht man zudem den Grund für das Verhalten von '''Call by Value''': | Die Methode <code>caller()</code> deklariert eine <code>int</code> Variable <code>i</code> mit dem Wert 5. Beim Aufruf von <code>callee(int a)</code> wird die übergebene Variable <code>i</code> nun zuerst zum Wert 5 aufgelöst. Dann wird die Funktion <code>callee(int a)</code> mit dem Wert 5 aufgerufen. Der Aufruf <code>callee(i)</code> ist also in diesem Falle nicht zu unterscheiden von einem Aufruf <code>callee(5)</code>. Hier sieht man zudem den Grund für das Verhalten von '''Call by Value''': | ||
| − | Wenn eine Funktion wie <code>callee(int a)</code> direkt mit einem konstanten Wert, wie <code>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 | + | Wenn eine Funktion wie <code>callee(int a)</code> direkt mit einem konstanten Wert, wie <code>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 [[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(){ | <source lang="Java">public static callee(){ | ||
Version vom 7. Februar 2016, 15:41 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 dann der resultierende Wert übergeben. Nehmen wir als Beispiel folgende zwei statische Methoden:
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, 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 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;
}
