Club Desarrolladores

¿Qué es un puntero?

Por definición un puntero es una variable que puede almacenar la dirección en memoria de otra variable. Según mi definición, un puntero es una entidad, que puede ser variable o constante, que siempre contiene una dirección de memoria (valida, inválida o nula), en la cual puede estar alojada una entidad de nuestro programa o no.
La declaración de una variable tipo puntero debe ser de la forma:

TipoVariableApuntada *NombreVariablePuntero;

Una variable de tipo puntero debe ser de igual tipo que la variable cuya dirección en memoria contiene, o dicho de otra forma, la variable a la que apunta.

Un puntero no tiene asociación directa con el dato actual, pero si una asociación indirecta. Por ese motivo se usa el termino “indirección” cuando se hace referencia a una asociación indirecta.

Cuando el compilador encuentra la declaración de una variable, le asigna una dirección en memoria en la que se almacenarán los valores que sucesivamente se le asignen a esa variable. El operador & antepuesto al nombre de una variable retorna el valor de la dirección inicial de memoria donde el compilador almacenó o almacenará el valor de la variable. Para acceder al valor que se encuentra en la dirección apuntada por un puntero se debe "dereferenciar" el puntero colocando * delante del mismo.
Por estos motivos se suele denominar a & el operador de referencia y a * el operador de indirección.
Veamos un ejemplo.

int *puntero; // Declara un puntero a una variable tipo int
int variable; /* Declara una variable tipo int. 
El compilador identifica y asigna direccion (supongamos 0x2710, en Hexadecimal)
 al identificador <variable> */
variable = 123456; /* Almacena en las direcciones 0x2710, 0x2711, 0x2712 y 0x2713 
el valor <123456>, tomando en cuenta que una variable de tipo int ocupa 4 bytes. 
Verifiquenlo en su compilador con sizeof(int) */
puntero = &variable; // Almacena 0x2710 en <puntero>

El operador * antepuesto a una variable puntero devuelve el valor que ésta almacena, partiendo de su dirección inicial, en un número de celdas de memoria, que viene definido por el tipo de la variable apuntada. Entonces, siguiendo con el ejemplo anterior:

int otra_variable; // Declara una variable tipo int
otra_variable = *puntero; /* Almacena en <otra_variable> el valor <123456>, 
el valor que contiene <variable> que es apuntada por <puntero> */

Acabamos de ver asignaciones de punteros. Ahora veamos la aritmética de punteros.
Una variable del tipo char ocupa 1 byte en la memoria y una variable de tipo int ocupa 4 bytes (verifiquen que tamaño tienen estos tipos de datos en sus compiladores).
Ahora bien, supongamos que creamos una variable de tipo char y ésta se aloja en la dirección 0x400, luego creamos un puntero a esa variable.

char c; // se crea en 0x400
char* pc;
pc = &c; // pc ahora apunta a 0x400

Utilizando los operadores de adición y sustracción podemos movernos a partir de la dirección relativa a la que apunta un puntero.

pc = pc + 1; /* pc ahora apunta a una direccion distinta, 
ya que se ha desplazado 1 byte en sentido positivo (1 direccion de memoria más alta), 
es decir que pc paso de apuntar de 0x400 a 0x401 */

Para volver a la posición anterior solo debemos escribir: pc-- o pc = pc - 1 o pc -= 1, es indistinto. Lo mismo ocurre con el operador +.

Si utilizamos otro tipo de dato, como por ejemplo int que ocupa 4 bytes, nos moveremos 4 unidades hacia delante (+) o hacia detrás (-) dependiendo del operador que utilicemos.

Para la comparación de punteros se utilizan los operadores básicos de comparación que usábamos con variables bases, tales como int. Por lo que para saber por ejemplo si un puntero apunta a la misma dirección a la que apunta otro, utilizaríamos: p1 == p2, para saber si son distintos utilizaríamos el operador !=, para saber si p1 apunta a una dirección de memoria mas baja que p2 colocaríamos p1 < p2, y así con los demás operadores de comparación.

Página 01 02 03 de 03 | Versión completa