A P U N T A D O R E S

Un apuntador es una variable cuyo valor es la dirección de memoria de otra variable. Se dice que un apuntador “apunta” a la
variable cuyo valor se almacena a partir de la dirección de memoria que contiene el apuntador. Por ejemplo, si un apuntador p
almacena la dirección de una variable x, se dice que “p apunta a x ”.

Referenciación: La referenciación es la obtención de la dirección de una variable. En C y C++ esto se hace a través del
operador ‘&’, aplicado a la variable a la cual se desea saber su dirección. Nótese que se trata de un operador unario. Ejemplo
(Código C y C++):

int x = 25;
cout << "La dirección de x es: " << &x << endl;

Este código imprime un valor del estilo “0x4fffd34”. Este valor puede variar durante cada ejecución del programa, debido a que
el programa puede reservar distintos espacios de memoria durante cada ejecución.

Declaración
Para declarar un apuntador se especifica el tipo de dato al que apunta, el operador ‘*’, y el nombre del puntador. La sintaxis es la
siguiente: <tipo de dato apuntado> *<indentificador del apuntador> . Ejemplo ( C++):
int *ptr1; // Apuntador a un dato de tipo entero (int)
char *cad1, *cad2; // Dos apuntadores a datos de tipo carácter (char)
float *ptr2; // Apuntador a un dato de tipo punto-flotante (float)

Asignación: Se pueden asignar a un apuntador direcciones de variables a través del operador de referenciación (‘&’) o
direcciones almacenadas en otros apuntadores. Ejemplos (Código C++):
int i = 5;
int *p, *q;
p = &i; // Se le asigna a ’p’ la dirección de ’i’
q = p; // Se le asigna a ’q’ la dirección almacenada en ’p’ (la misma de ’i’)

Desreferenciación: La desreferenciación es la obtención del valor almacenado en el espacio de memoria donde apunta un
apuntador. En C y C++ esto se hace a través del operador ‘*’, aplicado al apuntador que contiene la dirección del valor. Nótese
que se trata de un operador unario. Ejemplos (Código 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

Tipos: 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ólo se le pueden asignar direcciones de variables del tipo especificado en la
declaración del apuntador. Ejemplos (Código C++):

int *p1;
float *p2;
int x;
p1 = &x; // Esto es válido
p2 = &x; // Esto no es válido (el compilador genera un error)

Apuntadores a apuntadores: Dado que un apuntador es una variable que apunta a otra, fácilmente se puede deducir que
pueden existir apuntadores a apuntadores, y a su vez los segundos pueden apuntar a apuntadores, y as ıı sucesivamente. Estos
4apuntadores se declaran colocando tantos asteriscos (‘*’) como sea necesario. Ejemplos (Código C++):

char c = ’z’;
char *pc = &c;
char **ppc = &pc;
char ***pppc = &ppc;
***pppc = ’m’; // Cambia el valor de c a ’m’

Apuntadores constantes:
Es posible declarar apuntadores constantes. De esta manera, no se permite la modificación de la dirección almacenada en el
apuntador, pero sıı se permite la modificación del valor al que apunta. Ejemplos (Código C++):

int x = 5, y = 7;
int *const p = &x; // Declaración e inicialización del apuntador constante
*p = 3; // Esto es válido
p = &y; // Esto no es válido (el compilador genera un error)
#include <iostream> #include <iostream> #include <iostream>
using namespace std; using namespace std; using namespace std;
int numero = 12; int numero = 12; int numero = 12;
int main() int *puntero = &numero; int *puntero = &numero;
{
cout << &numero << endl; int main() int main()
cin.get(); { {
cout << puntero << endl; cout << *puntero << endl;
return 0; cin.get(); cin.get();
}
return 0; return 0;
} }

Operaciones.-
Se puede asignar a una variable puntero la dirección de una variable no puntero.
float x, *p;
.....
p=&x;

A una variable puntero puede asignarse el contenido de otra variable puntero si ambas variables son compatibles (ambos
punteros apuntan al mismo tipo de dato).
int *u, *v;
.....
u=v;
A un puntero es posible asignarle el valor NULL (el puntero no apunta a dirección de memoria alguna).
int *p;
p=NULL;
//Dirección nula: 0x0000000

Es posible sumar o restar una cantidad entera n a una variable puntero. La nueva dirección de memoria obtenida difiere en una
cantidad de bytes dada por: n por el tamaño del tipo apuntado por el puntero.
int *p;
.....
p+=4; //la dirección original de p se ha incrementado 16 bytes
p-=1; //La dirección anterior de p se decrementó en 4 bytes.

Es posible comparar dos variables puntero.

u<v u>=v u==v u!=v u==NULL

Declarar los siguientes apuntadores: Codificar las siguientes instrucciones:

• p como apuntador a long int
• s como apuntador a char
• nums_p como apuntador a apuntador a int
• aux como apuntador a s_registro
• Declarar una variable de tipo entero llamada a.
• Declarar un apuntador a entero llamado ptr.
• Asignar a ptr la dirección de a.
• Asignar a lo que apunta ptr el número 24.
• Escribir en pantalla el valor de a.
• Escribir en pantalla el contenido del apuntador ptr.
• Escribir en pantalla lo apuntado por ptr.
• ¿Qué valor es el que sale en la pantalla?

Codificar las siguientes instrucciones:

• Declarar 3 variables de tipo apuntador a entero llamadas a, b y c y dos enteros llamados i y j.

• Hacer que a y b apunten a i y que c apunte a j.
• Asignar a lo que apunta b un 4 y a lo que apunta c un 3.
• Asignar a lo que apunta a la suma del doble de lo que apunta b más lo que apunta c.
• Escribir en pantalla i y j.
• ¿Qué valores salen en la pantalla?

TAREA:

1.- Uso de punteros en Python. Argumente.

2.- Uso de apuntadores con vectores y matrices (ejemplifique usando C++)