Quelle est la différence entre
Pouvez-vous me donner des exemples, s'il vous plaît ?
C’est une façon de passer des arguments aux fonctions. Passer par référence signifie que le paramètre de la fonction appelée sera identique à l'argument passé par l'appelant (pas la valeur, mais l'identité - la variable elle-même). Le passage par valeur signifie que le paramètre de la fonction appelée sera une copie de l’argument passé par l’appelant. La valeur sera la même, mais l'identité - la variable - est différente. Ainsi, les modifications apportées à un paramètre par la fonction appelée changent dans un cas l'argument transmis et dans l'autre cas la valeur du paramètre dans la fonction appelée (qui n'est qu'une copie). Je suis pressé :
ref
utilisé à l'appelant et à la fonction appelée). Jon Skeet a également une bonne explication à ce sujet [ici][2].Codes
Puisque mon langage est le C++, je vais l'utiliser ici.
// 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);
}
Et un exemple en Java ne fera pas de mal :
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
] [3]
[http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_reference
] [4]
Ce type a tout compris :
[http://javadude.com/articles/passbyvalue.htm] [5]
[1] : http://www.yoda.arachsys.com/java/passing.html [2] : http://www.yoda.arachsys.com/csharp/parameters.html [3] : http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_value [4] : http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_reference [5] : http://javadude.com/articles/passbyvalue.htm
Voici un exemple :
#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
}
Lorsque vous passez par ref, vous passez essentiellement un pointeur vers la variable. En passant par value, vous passez une copie de la variable. Dans l'utilisation de base, cela signifie normalement que les changements de la variable passés par ref seront vus par la méthode appelante et que ceux passés par value ne le seront pas.