PUNTEROS

PROGRAMACION II

PROGRAMA: INGENIERIA INDUSTRIAL

PROFESOR: FRANKLIN DORIA

FREILER ALBERTO PRADO MAUSA

MONTERIA CRDOBA
UNICRDOBA
2015
1. Definicin de Puntero.

1
Un puntero es una variable cuyo contenido es una direccin de memoria. Cuando esta
direccin es la posicin de memoria de otra variable, se dice que el puntero apunta a esta
variable. Por tanto, podemos hacer la siguiente diferenciacin:

Direccin de memoria que ocupa el puntero: un puntero es una variable de

memoria, por tanto ocupa una direccin de la misma.

Direccin de memoria a la que apunta el puntero: el contenido de un puntero es

una direccin de memoria, a la cual se dice que apunta el puntero. Si la direccin
a la que apunta es la de otra variable, se dice que el puntero apunta a esa variable.

Contenido de la variable a la que apunta el puntero: la variable que est siendo

apuntada tendr un contenido, que podramos llamar el dato.

De forma grfica, un ejemplo podra representarse de la siguiente manera:

Memoria
Etiq. Direc. Contenido
P 1000 5000
... ...
... ...
V 5000 13,55
... ...

En ese caso, P es una variable de tipo puntero, ya que su contenido (5000) es una
direccin de memoria. El puntero P ocupa la direccin de memoria 1000, pero su
contenido es la direccin 5000. Esta direccin es la que ocupa la variable V, por lo que
se dice que P apunta a V. El contenido de V es realmente el dato en este caso, cuyo valor
es 13,55.

Se suele decir que un puntero es un caso de indireccin a una variable.

Para todo lo relacionado con punteros usaremos la sintaxis de C tambin para

pseudocdigo.

Un puntero, como una variable que es, debe ser declarada como cualquier otra variable.
En C un puntero se declara como sigue:

<tipo> *<nombre_puntero>;

donde tipo es el tipo de la variable a la que puede apuntar el puntero.

Ej.
int *pi;//pi podr apuntar a variables de tipo int.
char *pc;//pc podr apuntar a variables de tipo char.
float *pf;//pf podr apuntar a variables float.

Debe recordarse que puede visualizarse el contenido de un puntero, es decir a qu

direccin apunta, en formato hexadecimal, con el especificador %p en la funcin printf:

Ej.

2
 int x;
int *pi = &x;
...
printf(Direccin que ocupa x: %p, pi);
printf(Direccin que ocupa x: %p, &x);
//Ambos printf visualizan lo mismo.

Debe recordarse que cada posicin de memoria almacena 1 byte, es decir que el tipo de
cada variable indicar cuntas posiciones de memoria ocupa la variable, as tenemos:
char, 1 byte; int, 2 bytes; float, 4 bytes, etc.

2. Operadores que se aplican a punteros.

Existen dos operadores en C especialmente relacionados con los punteros. Son
los siguientes:

Operador &: se aplica a una variable y devuelve la direccin de memoria que

ocupa esa variable. Por tanto el valor que nos devuelve podr almacenarse en
un puntero.

Ej.
int *pi; //pi es un puntero a variables de tipo int.
int x; //x es una variable de tipo int.

pi = &x; //Con esta asignacin hacemos que el puntero

//pi apunte a la variable x, ya que &x nos
//devuelve la direccin de x.

Operador *: se aplica a un puntero y devuelve el contenido de la variable a la

que apunta el puntero.

Ej.
int *pi;
int x = 1;
int y;

pi = &x; //pi apunta a x. Despus de esta asignacin

//x ser equivalente a *pi. Por tanto:

y = *pi; //Almacena en y el contenido de x, ya que

//*pi es equivalente a x.

*pi = 0; //Almacena 0 en x.

3. Expresiones con Punteros.

Los punteros son un tipo especial de variable, por lo que no todas las operaciones de C
se pueden realizar sobre ellos. Veamos las que s se pueden hacer:

Inicializacin de punteros: un puntero, una vez declarado, contiene un valor

desconocido y por ese motivo debe ser inicializado. Si se intenta usar un

3
 puntero sin inicializar podemos incluso daar el sistema operativo, ya que
puede estar apuntando a cualquier direccin de memoria.

La forma de inicializar un puntero es asignarle una direccin conocida, es decir de una

variable declarada.

Ej.
int *pi;
int x;
pi = &x; //Apunta a x, direccin conocida.

Para indicar que un puntero inicialmente no apunta a nada se le puede asignar la

constante NULL (en maysculas), que est declarada en stdio.h y en stdlib.h. Esta
asignacin no implica que el puntero ya apunta a una direccin conocida. El valor NULL
es simplemente como bandera que puede usar el programador para indicar en el
programa que el puntero apunta a una direccin no concretada. Por tanto, si se usa un
puntero que apunta a NULL tambin puede daarse el sistema operativo.

Ej.
int *pi;

pi = NULL; //pi apunta a una direccin desconocida.

Asignacin de punteros: un puntero puede ser asignado a otro siempre que

ambos sean punteros del mismo tipo de variables. Despus de la asignacin,
ambos punteros apuntarn a la misma variable.

Ej.
int *ptr1, *ptr2;
int numero;
ptr1 = &numero;
ptr2 = ptr1; //ptr2 apuntar a donde ptr1, es decir a
//la variable numero.

Aritmtica de punteros: un puntero tan slo puede sumarse o restarse con

nmeros enteros. Ninguna otra operacin est permitida con punteros. Cada
unidad que se le sume a un puntero har que ste se incremente en el nmero
de bytes (n de posiciones de memoria) que ocupa el tipo al que apunta. Con
la resta el puntero se decrementa de la misma forma. Por ejemplo, si p es un
puntero al tipo int, p+1 apuntar a la direccin de memoria que est dos
posiciones posteriores a la que apunta p, ya que el tipo int ocupa 2 bytes. Si
se usa p+5, el puntero p se incrementa en 10 posiciones de memoria, ya que
cada incremento supone 2 posiciones (5*2=10).

Ej.
int n, *p = &n; //n es int; p es puntero a n.
p++; //Suma 1 a p, por tanto p se incrementa en dos
//posiciones de memoria (int ocupa 2 bytes).

char c, *p = &c; //c es char; p es puntero a c.

p--; //Resta 1 a p, por tanto p se decrementa en una
//posicin de memoria (char ocupa 1 byte).

4
 float f, *p = &f; //c es float; p es puntero a f.
p += 3; //Suma 3 a p, por tanto p se incrementa en 12
//posiciones de memoria: 3*4 (float = 4 bytes)

Estas operaciones se usan cuando se tienen varias variables del mismo tipo en
direcciones consecutivas de memoria, como ocurre con los arrays. Si un puntero
apunta a la primera componente del array, al sumarle una unidad apuntar a la
segunda componente, ya que se incrementa en el nmero de posiciones que ocupe
cada componente. Si se le suma 5 al puntero, apuntar a la quinta componente del
array. Igualmente ocurre con la resta, pero en el sentido inverso. En general, sumar o
restar enteros a punteros se usa para recorrer arrays, como veremos en un apartado
posterior.

Debe recordarse que declarar varias variables seguidas en un programa no implica

que ocupen posiciones consecutivas en memoria. Por este motivo, para variables que
no sean arrays no suele usarse esta aritmtica de punteros.

Se pueden aplicar tambin los operadores ++ -- += -= a punteros, como se

ve en algn ejemplo anterior.

Comparacin de punteros: los punteros pueden ser comparados en una

expresin relacional como cualquier variable. Si un puntero es menor que
otro, apunta a una direccin de memoria ms baja, es decir previa; si es
mayor, apunta a una direccin ms alta o posterior.

Ej.
int n, m;
int *p = &n, *q = &m;

if (p > q) //si p apunta a una direccin posterior

...

6. Punteros a funciones.
Los punteros tambin pueden usarse para que apunten a la direccin de memoria
donde comienza el cdigo de una funcin, de forma que podr realizarse una llamada a
esa funcin a travs de dicho puntero.