Gráfica comparativa:
| Bases para la comparación | Call_By_Value | Llamada por referencia |
|---|---|---|
| BASIC | Se pasa una copia de la variable. | Se pasa una variable en sí misma. |
| Efecto | El cambio en una copia de variable no modifica el valor original de la variable fuera de la función. | El cambio en la variable afecta también el valor de la variable fuera de la función. |
| Parámetros de llamada | function_name (variable_name1, variable_name2, .....); | function_name (& variable_name1, & variable_name2, ....); // en caso de objeto object.func_name (objeto); |
| Parámetros de recepción | escriba function_name (escriba variable_name1, escriba variable_name2, ......) {. . } | escriba function_name (escriba * variable_name1, escriba * variable_name2, ....) {. . } // en caso de objeto tipo function_name (class_type object_name) {. . } |
| Llamada predeterminada | El tipo primitivo se pasa usando "llamada por valor". | los objetos se pasan implícitamente usando "llamada por referencia". |
Definición de Call By Value
Si pasa un tipo de datos primitivo (entero, carácter y cadena) a una función / método, entonces solo su "valor" se pasa al código de función. La función copia ese valor de un argumento en un 'parámetro formal' del código de la función. Si hay alguna modificación al parámetro formal en un código de función, no se modificará el valor original del argumento que se usa para llamar a esa función.
En palabras simples, si una función / método se llama mediante el enfoque de "llamada por valor"; luego se pasa una copia de la variable al código de función. Si un código de función realiza algún cambio en el valor en la copia de la variable, no cambia el valor original de la variable.
Veamos un ejemplo para entender esto brevemente.
// ejemplo en Java class check {void change (int i, int j) {i = i * i; j = j / 2; system.out.println ("valor del parámetro dentro de la función"); system.out.println ("valor de 'i' que acepta el valor del argumento 'a'" + i); system.out.println ("valor de 'j' que acepta el valor del argumento 'b'" + j); }} class call_by _value {public static void main (string args []) {int a = 12, b = 20; cheque C = nuevo cheque (); system.out.println ("valor de 'a' y 'b' antes de la llamada a la función" + a + "" + b); C. cambio (a, b); // llamada por valor. system.out.println ("valor de 'a' y 'b' después de la llamada a la función" + a + "" + b); }} // el valor de salida de 'a' y 'b' antes de la función invoca el valor del parámetro dentro del valor de la función de 'i' que acepta el valor del argumento 'a' 144 el valor de 'j' que acepta el valor de argumento 'b' 10 valor de 'a' y 'b' después de la llamada a la función 12 20 Definición de llamada por referencia
El método de llamada por referencia pasa una referencia / dirección de un argumento al código de función. A medida que la dirección de un argumento se pasa al código de función, el parámetro formal que acepta esa dirección sería una variable 'puntero'. Ahora, como el código de función ha obtenido la dirección de un argumento, la modificación en el valor de un argumento también modificará el valor original de un argumento.
En C ++ y Java, es muy común pasar el objeto a la función / método y el objeto siempre se pasa por su referencia. Los cambios realizados en el objeto dentro de la función / método afectan al objeto utilizado para invocar esa función / método.
El siguiente fragmento muestra la forma correcta de 'llamar por referencia'.
// ejemplo en la clase C ++ swap {void swap (int * x, int * y) {int temp; temp = * x; * x = * y; * Y = temp; }} int main {int a = 10, b = 20; cout << "valor de a, b antes de la llamada a la función" << a << "" < Ahora analicemos 'llamada por referencia' pasando un 'objeto' como argumento, que se pasa implícitamente por el enfoque 'llamada por referencia'.
verificación de clase {int a, b; check (int x, int b) {// objeto inicializado a través de este constructor a = x; b = y; } void exchange (check ob) {ob.a = a * 2; ob.b = b / 2; }} class main_class {public static void main (string args []) {check C = new check (20, 40); // inicialización de objetos. system.out.println ("valor de 'ob.a' y 'ob.b' antes de la llamada a la función" + ob.a + "" + ob.b); C. intercambio (C); // llamada por referencia. system.out.println ("valor de 'ob.a' y 'ob.b' antes de la llamada a la función" + ob.a + "" + ob.b); }} // valor de salida de 'ob.a' y 'ob.b' antes de la llamada a la función 20 40 valor de 'ob.a' y 'ob.b' después de la llamada a la función 40 20 Diferencias clave entre la llamada por valor y la llamada por referencia
- Pasar el argumento utilizando el enfoque de 'llamada por valor' solo pasa la copia de esa variable, por lo que los cambios realizados en el valor en la copia de esa variable no afectan el valor original de esa variable. En el enfoque de 'llamada por referencia', la variable en sí se pasa como un argumento, por lo que los cambios en ella modifican el valor de la variable original.
- Si los argumentos pasados son tipos de datos primitivos, son simplemente "llamada por valor", pero si las referencias / direcciones de los argumentos u objetos se pasan, entonces se llama a una función mediante el método de "llamada por referencia".
- En 'enfoque de llamada por valor', los argumentos pasados son solo el nombre de las variables, mientras que, en el enfoque de 'llamada por referencia' los argumentos pasados son, nombre de variable a lo largo del signo '&' o un objeto que se pasa solo por su nombre.
- Los parámetros de recepción del argumento en el enfoque de 'llamada por valor' son nombres de variables junto con su tipo de datos. En el enfoque de 'llamada por referencia', el parámetro de recepción es siempre una variable de puntero junto con el tipo de datos y, en el caso de un objeto, es un nombre de objeto junto con su tipo de clase.
Conclusión:
C ++ y Java utilizan ambos enfoques dependiendo de lo que se pase. Si desea pasar solo el valor de la variable use el enfoque de "llamada por valor" y si desea ver el cambio en el valor original de la variable, utilice el enfoque de "llamada por referencia".
