Diferencia entre la llamada por referencia y llamada por valor | El uso del puntero

la llamada por referencia vs llamada por valor : En este artículo, vamos a aprender el diferencia entre llamadas por referencia y el valor de la llamada junto con el uso de puntero en C .

Si tenemos en cuenta el uso main del puntero, entonces es,

  1. Asignación dinámica de memoria
  2. la llamada por referencia

Diferencia de llamada por valor y llamada por referencia

  1. llamada por valor
  2. la llamada por referencia

en primer lugar, ir a través del código, ejecutarlo y seguir la salida.

Código:

#include <stdio.h>
#include <unistd.h>
//function for call by value
void swap_call_by_value(int a, int b)
{
//normal swap operation
int temp;
temp = a;
a = b; //a now have value of b
b = temp; //b now have value of a
printf("Printing with in the function call by value swap...n");
printf("value of a afrer swap(call by value) %d n", a);
printf("value of b afrer swap(call by value) %d n", b);
}
//function for call by reference
void swap_call_by_reference(int* a, int* b)
{
//follow the parameter
//a and b is now pointr type variables
//normal swap operation
int temp;
temp = *a; //temp stores value at address &a
*a = *b; //value at address &a is now value of address &b
*b = temp; //value at address &b is now temp
printf("Printing within the function call by reference swap...n");
printf("value of a afrer swap(call by reference) %d n", *a);
printf("value of b afrer swap(call by reference) %d n", *b);
}
int main()
{
int a = 10, b = 20;
printf("Let's swap using call by valuen");
sleep(2);
swap_call_by_value(a, b);
printf("the above function should have swapped already, n");
printf(" as it shows result printed with in functionn");
sleep(2);
printf("But is it swapped?n");
printf("Let's check by Printing here...n");
sleep(2);
printf("value of a after swap(call by value) %d n", a);
printf("value of b after swap(call by value) %d n", b);
printf("you can see value is same as before, no swapn");
sleep(2);
printf("What happened then?n");
sleep(1);
printf("But before lets swap perfectlyn");
printf("swapping by call by reference");
sleep(2);
//call by reference, address/reference is passed, not the value
swap_call_by_reference(&a, &b);
sleep(2);
printf("the above function should have swapped already, n");
printf("as it shows result printed with in functionn");
printf("But is it swapped?n");
printf("Let's check by Printing here...n");
sleep(2);
printf("value of a after swap(call by reference) %d n", a);
printf("value of b after swap(call by reference) %d n", b);
printf("you can see now value is swapped...n");
return 0;
}

Nota: El sueño () función que se utiliza en el código es sólo para fines de visualización, sin relación con el código.

salida

Let's swap using call by value
Printing with in the function call by value swap...
value of a afrer swap(call by value) 20
value of b afrer swap(call by value) 10
the above function should have swapped already,
as it shows result printed with in function
But is it swapped?
Let's check by Printing here...
value of a after swap(call by value) 10
value of b after swap(call by value) 20
you can see value is same as before, no swap
What happened then?
But before lets swap perfectly
swapping by call by referencePrinting within the function call by reference swap...
value of a afrer swap(call by reference) 20
value of b afrer swap(call by reference) 10
the above function should have swapped already,
as it shows result printed with in function
But is it swapped?
Let's check by Printing here...
value of a after swap(call by reference) 20
value of b after swap(call by reference) 10
you can see now value is swapped...

Explicación:

En de llamada por valor:

Se puede ver que dentro de la función parecía que ha intercambiado con éxito, pero cuando se imprime en el case función podemos ver los valores no han sido cambiados. La razón es el intercambio se llevó a cabo dentro de las variables locales de la función.

Nuestra llamada a la función en la función main: swap_call_by_value (a, b);

Aquí a, b es la variable definida en función de

Sin embargo, en la definición de función,

    void swap_call_by_value(int a, int b){
...
}

Aquí un , b es diferente, se trata de variables locales de la función anterior.

dicen que estos dos son local_a , local_b

Y un , b de la función main son main_a , main_b .

Direcciones de local_a , local_b es diferente de la main_a , main_b .

Por lo tanto, la operación de canje de la función también es local, el efecto no se refleja en función , pero funciona bien en la propia función.

main llamar a una función, la función guarda su variable local en su propio registro de activación. Por lo tanto, no se puede actualizar la variable de .

En main de llamadas por referencia

Está enviando direcciones de las variables en la función swap_call_by_value (& a, & b);

De ahí que el intercambio se lleva a cabo en la misma variable definida en la función main, por lo tanto, se refleja incluso en la función .

Es por eso que permuta por la función de utilizar siempre llamada por referencia, y en otros casos, se puede utilizar la llamada por referencia (uso de puntero) donde tiene que reflejar el efecto de la función de las variables declaradas en funciones While.


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *