¿Cuál es la diferencia entre
¿Podría darme algunos ejemplos, por favor?
Es una forma de pasar argumentos a las funciones. Pasar por referencia significa que el parámetro de la función a la que se llama será el mismo que el argumento pasado por el llamante (no el valor, sino la identidad, la propia variable). Pasar por valor significa que el parámetro de la función a la que se llama será una copia del argumento pasado por la persona que llama. El valor será el mismo, pero la identidad - la variable - es diferente. Así, los cambios en un parámetro realizados por la función llamada en un caso cambian el argumento pasado y en el otro caso sólo cambian el valor del parámetro en la función llamada (que es sólo una copia). De forma rápida:
ref
usada en el llamador y en la función llamada). Jon Skeet también tiene una buena explicación de esto aquí.Códigos
Ya que mi lenguaje es C++, lo usaré aquí
// 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);
}
Y un ejemplo en Java no estará de más:
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
Este tipo lo ha clavado:
He aquí un ejemplo:
lenguaje-todo: 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
}
Cuando se pasa por ref se está pasando básicamente un puntero a la variable. Al pasar por valor se pasa una copia de la variable. En el uso básico esto significa normalmente que los cambios en la variable al pasar por ref serán vistos por el método que llama y al pasar por valor no.