Tableau de comparaison:
| Base de comparaison | Call_By_Value | Appel par référence |
|---|---|---|
| De base | Une copie de la variable est passée. | Une variable elle-même est passée. |
| Effet | Le changement dans une copie de variable ne modifie pas la valeur d'origine de la variable en dehors de la fonction. | La modification de la variable affecte également la valeur de la variable en dehors de la fonction. |
| Paramètres d'appel | nom_fonction (nom_variable1, nom_variable2, ....); | nom_fonction (& nom_variable1, & nom_variable2, ...); // en cas d'objet object.func_name (object); |
| Paramètres de réception | type nom_fonction (type nom_variable1, type nom_variable2, ....) {. . } | type nom_fonction (type * nom_variable1, type * nom_variable2, ....) {. . } // en cas d'objet type nom_fonction (type_classe nom_objet) {. . } |
| Appel par défaut | type primitif sont passés en utilisant "call by value". | les objets sont implicitement passés en utilisant "appel par référence". |
Définition de Call By Value
Si vous transmettez un type de données primitif (entier, caractère et chaîne) à une fonction / méthode, seule sa «valeur» est transmise au code de la fonction. La fonction copie la valeur d'un argument dans un "paramètre formel" du code de la fonction. S'il y a modification du paramètre formel dans un code de fonction, cela ne modifiera pas la valeur d'origine de l'argument utilisé pour appeler cette fonction.
En termes simples, si une fonction / méthode est appelée par une approche "appel par valeur"; ensuite, une copie de la variable est transmise au code de fonction. Si un code de fonction modifie la valeur de la copie de la variable, il ne modifie pas la valeur d'origine de la variable.
Voyons un exemple pour comprendre ceci brièvement.
// exemple en classe Java check {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("valeur du paramètre dans la fonction"); system.out.println ("valeur de 'i' qui accepte la valeur de l'argument 'a'" + i); system.out.println ("valeur de 'j' qui accepte la valeur de l'argument 'b'" + j); }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; chèque C = nouveau chèque (); system.out.println ("valeur de 'a' et 'b' avant l'appel de fonction" + a + "" + b); Changement C. (a, b); // appel par valeur. system.out.println ("valeur de 'a' et 'b' après l'appel de fonction" + a + "" + b); }} // valeur de sortie de 'a' et 'b' avant l'appel de fonction 12 20 valeur du paramètre dans la valeur de fonction de 'i' qui accepte la valeur de l'argument 'a' 144 valeur de 'j' qui accepte la valeur de argument 'b' 10 valeur de 'a' et 'b' après l'appel de fonction 12 20 Définition d'appel par référence
La méthode Call by Reference transmet une référence / adresse d'un argument au code de fonction. Lorsque l'adresse d'un argument est transmise au code de la fonction, le paramètre formel acceptant cette adresse serait une variable "pointeur". Maintenant, comme le code de fonction a obtenu l'adresse d'un argument, la modification de la valeur d'un argument modifiera également la valeur d'origine d'un argument.
En C ++ et en Java, il est très courant de passer l'objet à la fonction / méthode et les objets sont toujours passés par sa référence. Les modifications apportées à l'objet dans la fonction / méthode affectent l'objet utilisé pour appeler cette fonction / méthode.
Le fragment suivant indique la méthode correcte pour "appeler par référence".
// exemple en classe C ++ swap {void swap (int * x, int * y) {int temp; temp = * x; * x = * y; * Y = temp; }} int main {int a = 10, b = 20; cout << "valeur de a, b avant l'appel de fonction" << a << "" < Parlons maintenant de "appel par référence" en passant un "objet" en tant qu'argument, lequel est implicitement transmis par l'approche "appel par référence".
contrôle de classe {int a, b; check (int x, int b) {// objet initialisé par ce constructeur a = x; b = y; } échange vide (cocher ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {public static void main (string args []) {check C = new check (20, 40); // initialisation d'objet. system.out.println ("valeur de 'ob.a' et 'ob.b' avant l'appel de fonction" + ob.a + "" + ob.b); Échange (C); // appel par référence. system.out.println ("valeur de 'ob.a' et 'ob.b' avant l'appel de fonction" + ob.a + "" + ob.b); }} // valeur de sortie de 'ob.a' et 'ob.b' avant l'appel de fonction 20 40 valeur de 'ob.a' et 'ob.b' après l'appel de fonction 40 20 Différences clés entre Call By Value et Call By Reference
- Passer l'argument en utilisant l'approche 'appel par valeur' ne fait que transmettre la copie de cette variable. Par conséquent, les modifications apportées à la valeur dans la copie de cette variable n'affectent pas la valeur d'origine de cette variable. Dans la méthode "appel par référence", la variable elle-même est transmise en tant qu'argument; ses modifications modifient donc la valeur de la variable d'origine.
- Si les arguments passés sont des types de données primitifs, ils sont simplement "appel par valeur", mais si les références / adresses des arguments ou objets sont passées, une fonction est appelée par la méthode "appel par référence".
- Dans 'approche par appel', les arguments passés ne sont que le nom des variables alors que, dans 'appel par référence', les arguments passés sont nom de variable avec le signe '&', ou un objet passé simplement par son nom.
- Les paramètres de réception de l'argument dans l'approche 'appel par valeur' sont un nom de variable ainsi que son type de données. Dans l'approche "appel par référence", le paramètre de réception est toujours une variable de pointeur avec le type de données et, dans le cas d'un objet, un nom d'objet avec son type de classe.
Conclusion:
C ++ et Java utilisent les deux approches en fonction de ce qui est transmis. Si vous souhaitez ne transmettre que la valeur de la variable, utilisez l'approche 'appel par valeur' et si vous souhaitez voir la modification de la valeur d'origine de la variable, utilisez l'approche 'appel par référence'.
