Was ist der Unterschied zwischen
Könnten Sie mir bitte einige Beispiele nennen?
Es ist ein Weg, um Argumente an Funktionen zu übergeben. Die Übergabe per Referenz bedeutet, dass der Parameter der aufgerufenen Funktion derselbe ist wie das vom Aufrufer übergebene Argument (nicht der Wert, sondern die Identität - die Variable selbst). Übergabe durch Wert bedeutet, dass der Parameter der aufgerufenen Funktion eine Kopie des vom Aufrufer übergebenen Arguments ist. Der Wert ist derselbe, aber die Identität - die Variable - ist anders. Änderungen an einem Parameter durch die aufgerufene Funktion ändern also in einem Fall das übergebene Argument und im anderen Fall nur den Wert des Parameters in der aufgerufenen Funktion (die nur eine Kopie ist). In aller Eile:
ref
beim Aufrufer und der aufgerufenen Funktion). Jon Skeet hat auch eine schöne Erklärung dazu hier.Codes
Da meine Sprache C++ ist, werde ich sie hier verwenden
// passes a pointer (called reference in java) to an integer
void call_by_value(int *p) { // :1
p = NULL;
}
// passes an integer
void call_by_value(int p) { // :2
p = 42;
}
// passes an integer by reference
void call_by_reference(int & p) { // :3
p = 42;
}
// this is the java style of passing references. NULL is called "null" there.
void call_by_value_special(int *p) { // :4
*p = 10; // changes what p points to ("what p references" in java)
// only changes the value of the parameter, but *not* of
// the argument passed by the caller. thus it's pass-by-value:
p = NULL;
}
int main() {
int value = 10;
int * pointer = &value;
call_by_value(pointer); // :1
assert(pointer == &value); // pointer was copied
call_by_value(value); // :2
assert(value == 10); // value was copied
call_by_reference(value); // :3
assert(value == 42); // value was passed by reference
call_by_value_special(pointer); // :4
// pointer was copied but what pointer references was changed.
assert(value == 10 && pointer == &value);
}
Und ein Beispiel in Java kann nicht schaden:
class Example {
int value = 0;
// similar to :4 case in the c++ example
static void accept_reference(Example e) { // :1
e.value++; // will change the referenced object
e = null; // will only change the parameter
}
// similar to the :2 case in the c++ example
static void accept_primitive(int v) { // :2
v++; // will only change the parameter
}
public static void main(String... args) {
int value = 0;
Example ref = new Example(); // reference
// note what we pass is the reference, not the object. we can't
// pass objects. The reference is copied (pass-by-value).
accept_reference(ref); // :1
assert ref != null && ref.value == 1;
// the primitive int variable is copied
accept_primitive(value); // :2
assert value == 0;
}
}
Wikipedia
http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_value
http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_reference
Dieser Typ bringt es ziemlich genau auf den Punkt:
Hier ist ein Beispiel:
#include <iostream>
void by_val(int arg) { arg += 2; }
void by_ref(int&arg) { arg += 2; }
int main()
{
int x = 0;
by_val(x); std::cout << x << std::endl; // prints 0
by_ref(x); std::cout << x << std::endl; // prints 2
int y = 0;
by_ref(y); std::cout << y << std::endl; // prints 2
by_val(y); std::cout << y << std::endl; // prints 2
}
Bei der Übergabe per ref übergeben Sie grundsätzlich einen Zeiger auf die Variable. Bei der Übergabe per Wert wird eine Kopie der Variablen übergeben. Im Normalfall bedeutet dies, dass die aufrufende Methode Änderungen an der Variablen sieht, während sie bei der Wertübergabe nicht gesehen werden.