Introduccin

Los apuntadores en C y C++ son una herramienta muy potente de programacin

que suele causar mucha confusin en los estudiantes que la estn aprendiendo.
Adems, cuando los programadores cometen un error en su utilizacin, puede
ser muy difcil 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 ms eficientes y ms flexibles.
En este artculo se explica de una manera sencilla y breve todo lo referente a la
utilizacin de apuntadores tanto en C como en C++. Todo lo explicado en este
artculo aplica tanto para C como para C++, a menos que se especifique un
lenguaje en particular. En algunos ejemplos de cdigo que son aplicables a C
aparecen instrucciones de entrada y salida de las libreras estndar de C++.

ndice

Apuntadores.......................................................................................................... 4
Declaracin de un apuntador...................................................................................4
Al trabajar con apuntadores se emplean dos operadores especficos:......................6
Aritmtica de apuntadores:..................................................................................... 8
Ejemplo de apuntadores:........................................................................................ 9
Conclusin........................................................................................................... 11
Infografa.............................................................................................................. 12

Apuntadores

Los apuntadores en C y C++ son una herramienta muy potente de

programacin. Cuando los programadores cometen un error en su utilizacin,
puede ser muy difcil encontrar el error, por lo cual es importante saber
utilizarlos. El uso de apuntadores en C y C++ es muy importante debido a que
permite hacer los programas ms eficientes y ms flexibles.

Cuando se declara una variable, el compilador reserva un espacio de memoria

para ella y asocia el nombre de esta a la direccin de memoria desde donde
comienzan los datos de esa variable.

Las direcciones de memoria se suelen describir como nmeros en hexadecimal.

Un apuntador es una variable cuyo valor es la direccin de memoria de otra
variable. Se dice que un apuntador apunta a la variable cuyo valor se
almacena a partir de la direccin de memoria que contiene el apuntador.

Declaracin de un apuntador

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:

<tipo de dato apuntado> *<indentificador del apuntador>

Ejemplos:
Codigo C y C++
int *ptr1; // Apuntador a un dato de tipo entero (int)
char *cad1, *cad2; // Dos apuntadores a datos de tipo carcter (char)
float *ptr2; // Apuntador a un dato de tipo punto-flotante (float)

int *ptrTotal;
//Estamos diciendo ptrTotal es un puntero que apunta a un valor entero (int).
double *ptrLiquidacion;
//ptrLiquidacion apunta a un valor double.
int *ptrTotal, contador;
//aqu tenemos una variable ptrTotal que apunta a un entero
//y una variable contador de tipo entera.
//no se debe asumir que contador es tambin un apuntador, ya que el *
No se distribuye.

Al trabajar con apuntadores se emplean dos operadores especficos:

Operador de direccin: & Representa la direccin de memoria de la variable
que le sigue:
&fnum representa la direccin de fnum.
Operador de contenido o in direccin: *. El operador * aplicado al nombre de un
apuntador indica el valor de la variable apuntada:
float altura = 26.92, *apunta;
apunta = &altura;
//inicializacin del apuntador
.printf(\n%f, altura);
//salida 26.92
.printf(\n%f, *apunta); //salida 26.92
No se debe confundir el operador * en la declaracin del
apuntador: int *p; Con

el

operador

en

las

instrucciones:
*p = 27;

printf(\nContenido = %d, *p);

Veamos con un ejemplo en C la diferencia entre todos estos conceptos Es decir:

int x = 25, *pint;
pint = &x;
La variable pint contiene la direccin de memoria de la variable x. La expresin:
*pint represen- ta el valor de la variable (x) apuntada, es decir 25. La variable pint
tambin tiene su propia di- reccin: &pint
Veamos con otro ejemplo en C la diferencia entre todos estos
conceptos void main(void) {
int a, b, c, *p1, *p2;
void *p;
p1 = &a;

// Paso 1. La direccin de a es asignada a p1

*p1 = 1;
p2 = &b;
*p2 = 2;
p1 = p2;
*p1 = 0;
p2 = &c;

// Paso 2. p1 (a) es igual a 1. Equivale a a = 1;

// Paso 3. La direccin de b es asignada a p2
// Paso 4. p2 (b) es igual a 2. Equivale a b = 2;
// Paso 5. El valor del p1 = p2
// Paso 6. b = 0
// Paso 7. La direccin de c es asignada a p2

Apuntadores

*p2 = 3;
printf("%d %d %d\n", a, b, c);
p = &p1;
p1 = p2;
*p1 = 1;
printf("%d %d %d\n", a, b, c);
}

// Paso 8. c = 3
// Paso 9. Qu se imprime?
// Paso 10. p contiene la direccin de p1
// Paso 11. p1= p2;
// Paso 12. c = 1
// Paso 13. Qu se imprime?

Vamos a hacer un seguimiento de las direcciones de memoria y de los valores de las

variables en cada paso. Suponemos que la variable a es colocada en la direccin 0000, b
en la siguiente, es decir 0002, con un offset de 2 bytes, por ser valores integer.
Se trata de un sistema de posiciones relativas de memoria. Se ver en aritmtica de
APUNTA- DORES.
Se obtiene el siguiente cuadro. En l reflejamos las direcciones relativas de memoria y los
cambios en cada uno de los pasos marcados:
Pa
so
1
2
3
4
5
6
7
8
9
10
11
12
13

a
00
00
1
1
1
1
1
1
1
1
1
1
1
1

b
0
0

2
2
0
0
0
0
0
0
0
0

c
00
04

3
3
3
3
1
1

p1
00
06
000
0
000
0
000
0
000
0
000
2
000
2
002
000
2
000
2
000
2
000
4
000
4
000
4

p2
00
08

p3
00
10

000
2
000
2
000
0
000
2
000
4
000
4
000
4
000
4
000
4
000
6
000
4

00
06
00
06
00
06
00
06

JAVIER BALSAS

Apuntadores

Aritmtica de apuntadores:
A una variable apuntador se le puede asignar la direccin de cualquier objeto.
-

A una variable apuntador se le puede asignar la direccin de otra

variable apuntador (siempre que las dos sealen el mismo
objeto)
A un apuntador se le puede inicializar con el valor NULL
Una variable apuntador puede ser restada o comparada con otra
si ambas apuntan a elementos de un mismo arreglo.
Se puede sumar o restar valores enteros: p++, pv+3, teniendo en
cuenta que el despla- zamiento (offset) depende del tipo de dato
apuntado:
p++;
pv+=3

//p apunta a la siguiente direccin

//pv apunta 3*n bytes del datoapuntado (offset)

Si tenemos:
float *decimal;
decimal++;

//suponemos que apunta a 0000

//apunta a 004

JAVIER BALSAS

Apuntadores

Ejemplo de apuntadores:
#include <iostream>
using std::cout;
using std::endl;
int main()
{
int x;
int y;
int *ptrEntero;
int *ptr2Entero;
ptrEntero = &x;
ptr2Entero = &y;
*ptrEntero = 1;
*ptr2Entero = 5;
cout << "El valor de x es: " << x << endl;
*ptrEntero += 5;
cout << "El valor de x, luego de incrementar 5 a *ptrEntero, es: "
<< x << endl;
cout << "El valor de y es: " << y << endl;
cout << "El valor de &y es: " << &y << endl;
cout << "El valor de ptr2Entero es: " << ptr2Entero << endl;
cout << "El valor de *ptr2Entero es: " << *ptr2Entero << endl;
cout << "El valor de &ptr2Entero es: " << &ptr2Entero << endl;
cout << "El valor de &*ptrEntero es: " << &*ptrEntero << " y el
valor de
*&ptrEntero es: " << *&ptrEntero << endl;
cout << "FIN DEL PROGRAMA :)" << endl;
return 0;
}

JAVIER BALSAS

Apuntadores

Ejemplo 2

#include<stdio.h>
int main(void)
{
int p,*ptr; //Un apuntador debe definirse del //mismo
tipo de la var apuntada
int *ptr2;
int **ptr3; //Definicin de un doble apuntador
p=0;
ptr=&p; //Segunda etapa: Asignacin de la //referencia
printf("p:%d\n",p);
printf("*ptr:%d; &ptr:%ld\n",*ptr,&ptr); //Indireccin y
direccin
printf("*&ptr:%ld; &*ptr:%p\n",*&ptr,&*ptr)
//*& y &* son complementarios
ptr2=ptr; //Un apuntador puede apuntar a otro
printf("*ptr:%d; *ptr2:%d\n",*ptr,*ptr2)
// %p es el formato para imprimir un puntero en su valor
HEXADECIMAL, funciona igual que %X
printf("*&ptr:%X\n",*&ptr);//Imprime la //direccin HEXA
de lo que se est apuntando
printf("&*ptr:%p\n",&*ptr);//Igual al anterio
printf("ptr:%X\n",&p);/*Imprime la direccin de la var p,
obviamente imprime lo mismo que la linea precedente*/
printf("&ptr:%X\n",&ptr);//Imprime la direccin //HEXA
donde esta el apuntador
printf("ptr:%X\n",ptr);/*Imprime lo que contiene la
variable apuntador, es decir la direccin de lo apuntado*/
printf("ptr:%ld\n",ptr2);/*Imprime lo que contiene la
variable apuntador, es decir la direccin de lo apuntado*/
*ptr3=ptr2; //El doble apuntador toma la //direccin de
un apuntador simple
printf("*ptr3:%p\n",&*(*ptr3));/*Imprime la direccin de
lo apuntado, note las implicaciones de imprimir un doble
apuntador*/
getchar();
getchar();
return 0;
}

JAVIER BALSAS

1
0

Apuntadores

Conclusin
Los apuntadores son una gran ayuda para referenciar variables. Su uso es
demasiado delicado. Un apuntador siempre referenciar direcciones. Un doble
apuntador es "una referencia de otra referencia". Los tipos de datos de apuntador
y variable apuntada deben coincidir. La memoria RAM direcciona todo en Sistema
HEXADECIMAL. Los apuntadores por defecto operan sobre direcciones HEXA. Un
operador puede ser impreso como HEXA o en su equivalente Entero Largo. Una
prctica sana es definir enteros largos sin signo para su manejo direccional.

Infografa
JAVIER BALSAS

1
1

Apuntadores
http://artemisa.unicauca.edu.co/~wpantoja/web/lab_int_inf/punteros_basico.ht
ml
Programacion en C++, del autor Luis Joyanes Aguilar, editorial Mc Graw Hill.
http://www.utm.mx/~mgarcia/PE7(Apuntadores).pdf
http://www.uhu.es/04004/material/Transparencias6.pdf

JAVIER BALSAS

1
2