Cuando se entra en una función, se reserva memoria local para los parámetros, y esos parámetros son considerados variables locales durante la existencia de la función.
Así por ejemplo supongamos la función toto que tiene un parámetro p que es un entero y devuelve un entero:
int toto( int p)
cuando se produce la llamada a toto, se reserva un espacio en memoria, apuntado por p, en el que cabe un entero.
Durante la función puedo llenar ese espacio de memoria con un valor, haciendo por ejemplo p=3 (en cuyo caso puse el valor 3 en la zona de memoria apuntada por p).
al finalizar la función toto se libera el espacio asignado a las variables locales a la función, incluyendo en este caso a p.
De modo tal que la función que llamó a toto no ve lo que valía p, esa zona de memoria eventualmente está sobreescrita pues ha sido liberada (recuerden que esa zona de memoria, junto a todas las variables locales de toto) solo debe "vivir" mientras estemos dentro de la función toto.
Cómo se resuelve esto?
En vez de pasar un valor como parámetro, pasamos un puntero a una cierta zona de memoria. Por ejemplo en el caso que nos ocupa sería
int toto( int *p)
ahora la variable local a toto ya no es p, sino la dirección de p. La zona de memoria donde va a ir el valor de p es algo que conoce el programa que llamó a toto. Dentro de la función toto yo puedo asignar un valor a p haciendo por ejemplo
*p = 3;
Lo pueden probar con un programa como este:
#include #include
int toto(int *p){
printf("al entrar en toto, *p = %d\n",*p);
*p = 3;
printf("al salir de toto, *p = %d\n",*p);
return 0;
}
int titi(int p){
printf("al entrar en titi, p = %d\n",p);
p = 8;
printf("al salir de titi, p = %d\n",p);
return 0;
}
int main(int argc, char* argv[])
{
int p=6;
toto(&p);
printf("luego de volver de toto %d\n",p);
p = 9;
titi(p);
printf("luego de volver de %d\n",p);
return 0;
}