Apuntadores en C y C++

Apuntadores en C y C++

Universidad de Carabobo

Facultad Experimental de Ciencias y Tecnolog´ıa

Prof. Marcos A. Gil T.

8 de diciembre de 2004

1. Introducci´on

Los apuntadores en C y C++ son una herramienta muy potente de programaci´on que suele causar mucha

confusi´on en los estudiantes que la est´an aprendiendo. Adem´as, cuando los programadores cometen un error

en su utilizaci´on, puede ser muy dif´ıcil encontrar el error, por lo cual es importante saber utilizarlos muy

bien. El uso de apuntadores en C y C++ es muy importante debido a que permite hacer los programas m´as

eficientes y m´as flexibles. En en este art´ıculo se explica de una manera sencilla y breve todo lo referente a la

utilizaci´on de apuntadores tanto en C como en C++.

Todo lo explicado en este art´ıculo aplica tanto para C como para C++, a menos que se especifique un

lenguaje en particular. En algunos ejemplos de c´odigo que son aplicables a C aparecen instrucciones de

entrada y salida de las librer´ıas est´andar de C++.

2. Definici´on de apuntador

Cuando se declara una variable, el compilador reserva un espacio de memoria para ella y asocia el nombre

de ´esta a la direcci´on de memoria desde donde comienzan los datos de esa variable. Las direcciones de memoria

se suelen describir como n´umeros en hexadecimal.

Un apuntador es una variable cuyo valor es la direcci´on de memoria de otra variable. Se dice que un

apuntador “apunta” a la variable cuyo valor se almacena a partir de la direcci´on de memoria que contiene el

apuntador. Por ejemplo, si un apuntador p almacena la direcci´on de una variable x, se dice que “p apunta a

x”.

3. Referenciaci´on

La referenciaci´on es la obtenci´on de la direcci´on de una variable. En C y C++ esto se hace a trav´es del

operador ‘&’, aplicado a la variable a la cual se desea saber su direcci´on. N´otese que se trata de un operador

unario. Ejemplo:

C´odigo C y C++

int x = 25;

cout << "La direcci´on de x es: " << &x << endl;

Este c´odigo imprime un valor del estilo “0x4fffd34”. Este valor puede variar durante cada ejecuci´on del

programa, debido a que el programa puede reservar distintos espacios de memoria durante cada ejecuci´on.

4. Declaraci´on de apuntadores

Para declarar un apuntador se especifica el tipo de dato al que apunta, el operador ‘*’, y el nombre del

apuntador. La sintaxis es la siguiente:

*

A continuaci´on se muestran varios ejemplos:

C´odigo C y C++

int *ptr1; // Apuntador a un dato de tipo entero (int)

char *cad1, *cad2; // Dos apuntadores a datos de tipo car´acter (char)

float *ptr2; // Apuntador a un dato de tipo punto-flotante (float)

5. Asignaci´on de apuntadores

Se pueden asignar a un apuntador direcciones de variables a trav´es del operador de referenciaci´on (‘&’) o

direcciones almacenadas en otros apuntadores. Ejemplos:

C´odigo C y C++

int i = 5;

int *p, *q;

p = &i; // Se le asigna a ’p’ la direcci´on de ’i’

q = p; // Se le asigna a ’q’ la direcci´on almacenada en ’p’ (la misma de ’i’)

6. Desreferenciaci´on de apuntadores

La desreferenciaci´on es la obtenci´on del valor almacenado en el espacio de memoria donde apunta un

apuntador. En C y C++ esto se hace a trav´es del operador ‘*’, aplicado al apuntador que contiene la

direcci´on del valor. N´otese que se trata de un operador unario. Ejemplos:

C´odigo C y C++

int x = 17, y;

int *p;

p = &x;

cout << "El valor de x es: " << *p << endl; // Imprime 17

y = *p + 3; // A ’y’ se le asigna 20

C++ adem´as provee el operador binario ‘->’, utilizado para obtener campos de un registro con un apunta-

dor al mismo de una manera m´as f´acil y legible. Muchos compiladores de C tambi´en soportan este operador.

Ejemplo:

2

C´odigo C++

struct Data

{

char nombre[20];

int edad;

};

Data d;

Data *pd = &d;

(*pd).edad = 23; // Acceso al campo ’edad’ utilizando el operador ’.’

pd->edad = 23; // Acceso al campo ’edad’ utilizando el operador ’->’

7. Verificaci´on de tipos en apuntadores

Al igual que el resto de las variables, los apuntadores se enlazan a tipos de datos espec´ıficos (apuntadores

a variables de cierto tipo), de manera que a un apuntador s´olo se le pueden asignar direcciones de variables

del tipo especificado en la declaraci´on del apuntador. Ejemplo:

C´odigo C y C++

int *p1;

float *p2;

int x;

p1 = &x; // Esto es v´alido

p2 = &x; // Esto no es v´alido (el compilador genera un error)

8. Direcciones inv´alidas y la direcci´on NULL

Normalmente, un apuntador inicializado adecuadamente apunta a alguna posici´on espec´ıfica de la memo-

ria. Sin embargo, algunas veces es posible que un apuntador no contenga una direcci´on v´alida, en cuyo caso

es incorrecto desreferenciarlo (obtener el valor al que apunta) porque el programa tendr´a un comportamiento

impredecible y probablemente err´oneo, aunque es posible que funcione bien. Un apuntador puede contener

una direcci´on inv´alida debido a dos razones:

1. Cuando un apuntador se declara, al igual que cualquier otra variable, el mismo posee un valor cualquiera

que no se puede conocer con antelaci´on, hasta que se inicialice con alg´un valor (direcci´on). Ejemplo:

C´odigo C y C++

float *p;

cout << "El valor apuntado por p es: " << *p << endl; // Incorrecto

*p = 3.5; // Incorrecto

2. Despu´es de que un apuntador ha sido inicializado, la direcci´on que posee puede dejar de ser v´alida si

se libera la memoria reservada en esa direcci´on, ya sea porque la variable asociada termina su ´ambito

o porque ese espacio de memoria fue reservado din´amicamente y luego se liber´o . Ejemplo:1

1La asignaci´on din´amica de memoria se explica en la secci´on 13

3

C´odigo C y C++

int *p, y;

void func()

{

int x = 40;

p = &x;

y = *p; // Correcto

*p = 23; // Correcto

}

void main()

{

func();

y = *p; // Incorrecto

*p = 25; // Incorrecto

}

Si se intenta desreferenciar un apuntador que contiene una direcci´on inv´alida pueden ocurrir cosas como

las siguientes:

Se obtiene un valor incorrecto en una o m´as variables debido a que no fue debidamente inicializada

la zona de memoria que se accede a trav´es de la direcci´on en cuesti´on. Esto puede ocasionar que el

programa genere resultados incorrectos.

Si casualmente la direcci´on es la misma de otra variable utilizada en el programa, o est´a dentro del

rango de direcciones de una zona de memoria utilizada, existe el riesgo de sobreescribir datos de otras

variables.

Existe la posibilidad de que la direcci´on est´e fuera de la zona de memoria utilizada para almacenar

datos y m´as bien est´e, por ejemplo, en la zona donde se almacenan las instrucciones del programa. Al

intentar escribir en dicha zona, f´acilmente puede ocurrir que el programa genere un error de ejecuci´on

y el sistema operativo lo detenga, o que el programa no responda y deje al sistema operativo inestable.

En muchos casos el sistema operativo detecta el acceso inadecuado a una direcci´on de memoria, en cuyo

caso detiene abruptamente el programa.

Cuando no se desea que un apuntador apunte a algo, se le suele asignar el valor NULL, en cuyo caso se

dice que el apuntador es nulo (no apunta a nada). NULL es una macro t´ıpicamente definida en archivos de

cabecera como stdef.h y stdlib.h. Normalmente, en C++ se encuentra disponible sin incluir ning´un archivo

de cabecera. NULL se suele definir en estas librer´ıas as´ı:

...