Qual è la differenza tra
Potresti farmi qualche esempio, per favore?
È un modo per passare argomenti alle funzioni. Passare per riferimento significa che il parametro della funzione chiamata sarà lo stesso dell'argomento passato dal chiamante (non il valore, ma l'identità - la variabile stessa). Passare per valore significa che il parametro della funzione chiamata sarà una copia dell'argomento passato dal chiamante. Il valore sarà lo stesso, ma l'identità - la variabile - è diversa. Quindi le modifiche ad un parametro fatte dalla funzione chiamata in un caso cambiano l'argomento passato e nell'altro caso cambiano solo il valore del parametro nella funzione chiamata (che è solo una copia). In fretta e furia:
ref
usata al chiamante e alla funzione chiamata). Jon Skeet ha anche una bella spiegazione di questo qui.Codici
Dato che il mio linguaggio è il C++, lo userò qui
// 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);
}
E un esempio in Java non farà male:
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
Questo tizio lo inchioda più o meno:
Ecco un esempio:
-- lingua-tutto: c++ -->
#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
}
Quando si passa per ref si sta fondamentalmente passando un puntatore alla variabile. Passando per valore state passando una copia della variabile. Nell'uso di base questo significa normalmente che le modifiche alla variabile pass by ref saranno viste dal metodo chiamante, mentre quelle pass by value non lo saranno.