Direcciones de variables
Al declarar una variable estamos diciendo al ordenador que reserve una parte de la memoria RAM para almacenarla. Cada vez que ejecutemos el programa la variable se almacenará en un sitio diferente; eso no lo podemos controlar; depende de la memoria disponible y de otros varios factores. Puede que se almacene en el mismo sitio, pero es mejor no fiarse. Dependiendo del tipo de variable que declaremos, el ordenador reservará más o menos memoria. Como vimos en la sección Variables cada tipo de variable ocupa más o menos bytes. Por ejemplo, si declaramos un char, el ordenador reserva 1 byte (8 bits). Cuando finaliza el programa todo el espacio reservado queda libre.
Existe una forma de saber qué direcciones ha reservado el ordenador. Se trata de usar el operador & (operador de dirección). Vamos a ver un ejemplo: definimos la variable a y obtenemos su valor y dirección.
#include <stdio.h>
main()
{
int a = 10;
printf( "Dirección de a = %p, valor de a = %i\n", &a, a );
}
|
Para mostrar la dirección de la variable usamos %p en lugar de %i. Sirve para escribir direcciones de punteros y variables. El valor se muestra en formato hexadecimal.
No hay que confundir el valor de la variable con la dirección donde está almacenada. La variable a está almacenada en un lugar determinado de la memoria y ese lugar no cambia mientras se ejecuta el programa. El valor de la variable puede cambiar a lo largo del programa, lo cambiamos a voluntad mediante el código. Ese valor está almacenado en la dirección de la variable. El identificador (nombre) de la variable es equivalente a poner un nombre a una zona de la memoria. Cuando en el programa escribimos a, en realidad estamos diciendo, "el valor que está almacenado en la dirección de memoria a la que llamamos a".
Ahora ya estamos en condiciones de ver lo que es un puntero. Un puntero es una variable un tanto especial. Con un puntero podemos almacenar direcciones de memoria. En un puntero podemos tener guardada la dirección de una variable. Veamos la diferencia entre una variable puntero y las variables "normales".
En el dibujo anterior tenemos una representación de lo que puede ser la memoria del ordenador. Cada casilla representa un byte de la memoria. Y cada número es su dirección de memoria. La primera casilla es la posición 00001. La segunda casilla es la posición 00002, y así sucesivamente. Supongamos que ahora declaramos una variable: char numero = 43. El ordenador guardaría, por ejemplo, esta variable en la posición 00003. Esta posición de la memoria queda reservada y ya no la puede usar nadie más. Además, esta posición a partir de ahora se denomina numero. Como le hemos asignado el valor 43, el valor 43 se almacena en la posición de memoria 00003.
Si ahora usáramos el programa siguiente:
#include <stdio.h>
main()
{
int numero = 43;
printf( "Dirección de numero = %p, valor de numero = %i\n",
&numero, numero );
}
|
el resultado sería:
Dirección de numero = 00003, valor de numero = 43 |
Hemos dicho que un puntero sirve para almacenar la direcciones de memoria. Muchas veces los punteros se usan para guardar las direcciones de variables. Como cada tipo de variable ocupaba un espacio distinto, cuando declaramos un puntero debemos especificar el tipo de datos cuya dirección almacenará. En el próximo ejemplo queremos utilizar un puntero que almacene la dirección de una variable int. Así que para declararlo debemos hacer:
int *punt;
El * (asterisco) sirve para indicar que se trata de un puntero y debe ir justo antes del nombre de la variable, sin espacios. En la variable puntsólo se pueden guardar direcciones de memoria, no se pueden guardar datos. Vamos a volver sobre el ejemplo anterior un poco ampliado para ver cómo funciona un puntero:
#include <stdio.h>
main()
{
int numero;
int *punt;
numero = 43;
punt = №
printf( "Dirección de numero = %p, valor de numero = %i\n",
punt, numero );
}
|
Vamos a analizar línea a línea:
- En la primera, int numero;, reservamos memoria para numero (supongamos que queda como antes, en la posición 00003). Por ahoranumero no tiene ningún valor.
- Siguiente línea: int *punt;, reservamos una posición de memoria para almacenar el puntero. Lo normal es que a medida que se declaran variables se guarden en posiciones contiguas. De modo que quedaría en la posición 00004. Por ahora punt no tiene ningún valor, es decir, no apunta a ninguna variable. Esto es lo que tenemos por ahora:
- Tercera línea: numero = 43;. Aquí estamos dando el valor 43 a numero. Se almacena 43 en la dirección 00003, que es la de numero.
- Cuarta línea: punt = №. Por fin damos un valor a punt. El valor que le damos es la dirección de numero (ya hemos visto que &devuelve la dirección de una variable). Así que punt tendrá como valor la dirección de numero, 00003. Por lo tanto tenemos:
Cuando un puntero tiene la dirección de una variable se dice que ese puntero apunta a esa variable. La declaración de un puntero depende del tipo de dato al que queramos apuntar. En general, la declaración es:
tipo_de_dato *nombre_del_puntero;
Para qué sirve un puntero y cómo se usa
Los punteros tienen muchas utilidades; por ejemplo, nos permiten pasar argumentos (o parámetros) a una función y modificarlos. También permiten el manejo de cadenas y de arrays. Otro uso importante es que nos permiten acceder directamente a la pantalla, al teclado y a todos los componentes del ordenador. Si sólo sirvieran para almacenar direcciones de memoria no serían de mucha utilidad. Nos deben dejar también la posibilidad de acceder al contenido de esas posiciones de memoria. Para ello se usa el operador * (operador de indirección), que no hay que confundir con el de la multiplicación.
#include <stdio.h>
main()
{
int numero;
int *punt;
numero = 43;
punt = №
printf( "Dirección de numero = %p, valor de numero = %i\n",
punt, *punt );
}
|
Si nos fijamos en lo que ha cambiado con respecto al ejemplo anterior, vemos que para acceder al valor de numero usamos *punt. Esto es así porque punt apunta a numero y *punt nos permite acceder al valor al que apunta punt.
#include <stdio.h>
main()
{
int numero;
int *punt;
numero = 43;
punt = №
*punt = 30;
printf( "Dirección de numero = %p, valor de numero = %i\n",
&numero, numero );
}
|
Ahora hemos cambiado el valor de numero a través de *punt. El resultado sería:
Dirección de numero = 00003, valor de numero = 30 |
En resumen, usando punt podemos apuntar a una variable y con *punt vemos o cambiamos el contenido de esa variable.
Un puntero no sólo sirve para apuntar a una variable, también sirve para apuntar una dirección de memoria determinada. Esto tiene muchas aplicaciones; por ejemplo nos permite controlar el hardware directamente (en MS-DOS y Windows, no en Linux). Podemos escribir directamente sobre la memoria de video y así escribir directamente en la pantalla sin usar printf.
Uso de punteros en comparaciones
Veamos el siguiente ejemplo. Queremos comprobar si dos variables son iguales usando punteros:
#include <stdio.h>
main()
{
int a, b;
int *punt1, *punt2;
a = 5; b = 5;
punt1 = &a; punt2 = &b;
if ( punt1 == punt2 )
printf( "Son iguales\n" );
}
|
Alguien podría pensar que el if se cumple y se mostraría el mensaje Son iguales en pantalla. Pero no es así, el programa es erróneo. Es cierto que a y b son iguales. También es cierto que punt1 apunta a a y punt2 a b. Lo que queríamos comprobar era si a y b son iguales. Sin embargo, con la condición estamos comprobando si punt1 apunta al mismo sitio que punt2, estamos comparando las direcciones donde apuntan. Por supuesto a y b están en distinto sitio en la memoria, así que la condición es falsa. Para que el programa funcione deberíamos usar los asteriscos:
#include <stdio.h>
main()
{
int a, b;
int *punt1, *punt2;
a = 5; b = 5;
punt1 = &a; punt2 = &b;
if ( *punt1 == *punt2 )
printf( "Son iguales\n" );
}
|
Ahora sí. Estamos comparando el contenido de las variables a las que apuntan punt1 y punt2. Debemos tener mucho cuidado con esto porque es un error muy frecuente.
Vamos a cambiar un poco el ejemplo. Ahora b no existe y punt1 y punt2 apuntan a a. La condición se cumplirá porque apuntan al mismo sitio.
#include <stdio.h>
main()
{
int a;
int *punt1, *punt2;
a = 5
punt1 = &a; punt2 = &a;
if ( *punt1 == *punt2 )
printf( "punt1 y punt2 apuntan al mismo sitio\n" );
}
|
Punteros como argumentos de funciones
Hemos visto en la sección Funciones cómo pasar parámetros y cómo obtener resultados de las funciones (con los valores devueltos mediantereturn). Pero tiene un inconveniente, sólo podemos devolver un único valor. Ahora vamos a ver cómo los punteros nos permiten modificar varias variables en una función.
Hasta ahora para pasar una variable a una función hacíamos lo siguiente:
#include <stdio.h>
int suma( int a, int b )
{
return a+b;
}
main()
{
int var1, var2;
var1 = 5; var2 = 8;
printf( "La suma es : %i\n", suma(var1, var2) );
}
|
Aquí hemos pasado a la función los parámetros a y b (que no podemos modificar) y nos devuelve la suma de ambos. Supongamos ahora que queremos tener la suma pero además queremos que var1 se haga cero dentro de la función. Haríamos lo siguiente:
#include <stdio.h>
int suma( int *a, int b )
{
int c;
c = *a + b;
*a = 0;
return c;
}
main()
{
int var1, var2;
var1 = 5; var2 = 8;
printf( "La suma es: %i y a vale: %i\n", suma(&var1, var2), var1 );
}
|
Fijémonos en lo que ha cambiado (con letra en negrita): En la función suma hemos declarado a como puntero. En la llamada a la función (dentro de main) hemos puesto & para pasar la dirección de la variable var1. Ya sólo queda hacer cero a var1 a través de *a=0. También usamos una variable c que nos servirá para almacenar la suma a+b.
Es importante no olvidar el operador & en la llamada a la función ya que sin él no estaríamos pasando la dirección de la variable sino cualquier otra cosa.
0 comentarios:
Publicar un comentario