Paso 4: Utilización de punteros
PASAR ARGUMENTOS A UNA FUNCIÓNHay dos formas de pasar argumentos a una función: por valor o por referencia.
PASAR ARGUMENTOS POR VALOR
Normalmente, se pasan argumentos a funciones por valor, lo que significa que es el valor de la variable que se pasa a la función y no la variable sí mismo.
Las implicaciones de esto evidente en el fragmento siguiente de código:
void fn (int nArg1, int nArg2)
{
modificar los valores de los argumentos
nArg1 = 10;
nArg2 = 20;
}
principal de la int (int nNumberofArgs, char * pszArgs [])
{
initiaize dos variables y mostrar sus valores
int nValue1 = 1;
int nValue2 = 2;
ahora probar y modificar llamando a una función
FN (nValue1, nValue2);
¿Cuál es el valor de nValue1 y nValue2 ahora?
cout cout
sistema ("PAUSE")
return 0;
}
Este programa declara dos variables, nValue1 y nValue2, inicializa a un valor conocido y pasa sus valores a una función de (fn). Esta función cambia el valor de sus argumentos y simplemente vuelve.
Pregunta: ¿Qué es el valor de nValue1 y nValue2 (principal) después de que se devuelve el control de (fn)?
Respuesta: El valor de nValue1 y nValue2 permanecen inalterados en el 1 y 2, respectivamente.
Para entender por qué, examinar cuidadosamente cómo C++ maneja memoria en la llamada (fn). C++ almacena variables locales (como nValue1 y nValue2) en una zona especial de memoria conocida como la pila. Entrada en una función, C++ figuras cómo mucha memoria de pila la función requiere y entonces reserva esa cantidad. Decir, por el bien del argumento, que en este ejemplo, la memoria de pila tallada hacia fuera (principal) comienza en la ubicación 0x1000 y se extiende hasta 0x101F. En este caso, podría ser nValue1 en lugar 0x1000 y nValue2 podría ser en lugar de 0x1004.
(NOTA: SI ESTÁ UTILIZANDO CODE::BLOCKS, UN INT OCUPA 4 BYTES.)
Como parte de la llamada (fn), C++ primero almacena los valores de cada argumento en la pila a partir de la discusión de la derecha y trabajando su camino a la izquierda.
Lo último que C++ almacena como parte de la llamada es la dirección de retorno para que la función sabe donde volver después de que sea completa.
Por razones que tienen que ver más con el funcionamiento interno de la CPU, la pila de "crece hacia abajo", lo que significa la memoria utilizada por (fn) tendrá direcciones más pequeño que 0x1000.
Recuerde que esto es sólo un posible diseño de la memoria. No sabe (o cuidado) que cualquiera de estos en realidad son las direcciones reales utilizadas por C++ en esta o cualquier otra llamada de función.
La función fn (int, int) contiene dos afirmaciones:
nArg1 = 10;
nArg2 = 20;
El punto principal de decir esto es demostrar el hecho de que cambiando los valores de nArg1 y nArg2 no tiene ningún efecto en las variables originales en nValue1 y nValue2.
PASAR ARGUMENTOS POR REFERENCIA
Así que ¿qué pasa si quería los cambios realizados por (fn) sea permanente? Podría hacer esto por pasar no el valor de las variables, pero su dirección. Esto se demuestra por el siguiente fragmento de código:
void fn (int * pnArg1, int * pnArg2)
{
modificar el valor de los argumentos
* pnArg1 = 10;
* pnArg2 = 20;
}
principal de la int (int nNumberofArgs, char * pszArgs [])
{
inicializar dos variables y mostrar sus valores
int nValue1 = 1;
int nValue2 = 2;
FN (nValue1 & nValue2);
sistema ("PAUSE")
return 0;
}
Primero, observe que los argumentos de (fn) son ahora declarados no enteros sino punteros a enteros. La llamada a fn (int *, int *) pasa no el valor de las direcciones de las variables nValue1 y nValue2 pero mesas.
Mediante el uso de los punteros, los cambios realizados en las dos variables se convierten en permanentes. Sin usar los punteros, los cambios sólo se realizan a los valores copiados (fn).
