Estructuras de Datos

III. Apuntadores
Resumen
 Apuntadores

Objetivos
• Comprender los apuntadores y los operadores para
apuntadores.
• Utilizar los apuntadores para pasar por referencia
argumentos a una función.
• Comprender las relaciones entre apuntadores y arreglos
• Utilizar apuntadores a estructuras
 Conceptos generales

Reglas básicas:
1. un apuntador es una variable como cualquier
otra;
2. una variable apuntador contiene una dirección
que apunta a otra posición en memoria;
3. en esa posición (dirección) se almacenan los
datos a los que apunta el apuntador
 Conceptos generales
Cada variable que se declara en C tiene una
dirección asociada a ella.
int x=10;

Variable x
Valor     10      
Dirección 008C70C 008C710 0x6ffe0c 008C718 008C71C ...
 Conceptos generales
Cada variable que se declara en C tiene una
dirección asociada a ella.
int x=10;
float y=5;
Variable y x
Valor  5   10      
Dirección 008C70C 008C710 0x6ffe0c 008C718 008C71C ...
 Dirección asociada a una Ej 1
variable &
Obtener el valor y la dirección de una variable

#include<iostream>
using namespace std;

main()
{
int x=10;
cout<<"Valor de "<<x<<endl;
cout<<"Direccion de x "<<&x<<endl;
}
1. Definición o declaración de un
apuntador
Operador *
Cada variable que se declara en C tiene una
dirección asociada a ella.

int x=10, *ptrx; Definición de un apuntador

float y=5;
Variable y x ptrx
Valor  5   10    Basura  
Dirección 008C70C 008C710 0x6ffe0c 008C718 0x6ffe00 ...
 Operador de dirección & Ej 2

Dirección a un apuntador

#include<iostream> Como los apuntadores son

using namespace std; variables también tienen una
dirección

main()
{
int x=10, *ptrx;
cout<<"Valor de x -----------"<<x<<endl;;
cout<<"Direccion de x--------"<<&x<<endl;
cout<<"Valor de ptrx --------"<<ptrx<<endl;
cout<<"Direccion de &ptrx ---"<<&ptrx<<endl;
}
 Operador de dirección & Ej 2

Resultados

Basura

9
 2. Asignación de una dirección a
un apuntador
Cada variable que se declara en C tiene una
dirección asociada a ella.
int x=10, *ptrx;
float y=5; ptrx apunta a x
ptrx=&x;
Variable y x ptrx
Valor  5   10   0x6ffe0c   
Dirección 008C70C 008C710 0x6ffe0c 008C718 0x6ffe00 ...
Como los apuntadores son variables también
tienen una dirección
Asignación de una dirección a un Ej 3
apuntador
#include<iostream>
Operador &
using namespace std;

main()
{
int x=10, *ptrx;
cout<<"Valor de x -----------"<<x<<endl;;
cout<<"Direccion de x--------"<<&x<<endl;
cout<<"Valor de ptrx --------"<<ptrx<<endl;
cout<<"Direccion de &ptrx ---"<<&ptrx<<endl<<endl;
ptrx=&x;
cout<<"Valor de ptrx --------"<<ptrx<<endl;
cout<<"Direccion de &ptrx ---"<<&ptrx<<endl;
} 11
Asignación de una dirección a un Ej 3
apuntador

Basura

Dirección de x
asignada a ptrx

12
 Apuntadores

Definición: Hay dos sentidos

1. Sinónimo de la dirección de un dato
2. Variable que contiene una dirección a un
dato de un tipo concreto.
(Definición más exacta).
 Indirección de apuntadores
El uso de un apuntador para obtener el valor al que apunta,
*
es decir, su dato apuntado se denomina indireccionar el
apuntador (“desreferenciar el apuntador”); para ello se
utiliza el operador de indirección *.

int x=10, *ptrx; *ptrx = ???

float y=5; ptrx apunta a x
ptrx=&x;
Variable y x ptrx
Valor  5   10   0x6ffe0c   
Dirección 008C70C 008C710 0x6ffe0c 008C718 0x6ffe00 ...
 Indirección de apuntadores

int x=10, *ptrx; *ptrx = 10

float y=5; ptrx apunta a x
ptrx=&x;
Variable y x ptrx
Valor  5   10   0x6ffe0c   
Dirección 008C70C 008C710 0x6ffe0c 008C718 0x6ffe00 ...

cout<<"x a traves de ptrx ---"<<*ptrx; Ej 4

 Void * y NULL

· Apuntador nulo: NULL (definido en stdio.h)

• Se puede usar como valor de inicialización
• Usado en algunas funciones como valor de error.
• Los apuntadores se pueden usar como booleanos.
NULL es false y cualquier otra cosa es true.

Un apuntador nulo no direcciona ningún dato válido. Un apuntador

void direcciona datos de un tipo no especificado. Un apuntador void
se puede igualar a nulo si no se direcciona ningún dato válido. NULL
es un valor; void es un tipo de dato.
 Apuntadores y Arreglos
- Declaración de tablas:
dimensión
tipo nombre[dim];
int ti[2];
char tc[4];
· Observación:
El nombre del arreglo es el nombre simbólico (constante) de la dirección constante del
primer byte del arreglo => son direcciones constantes (no son apuntadores que puedan
variar).
- Ejemplo:
int ti[2], *pi;
pi = ti;
variable direc. de int
ti  arreglo  sinónimo de dirección del primer
ti = pi; <= absurdo
byte del arreglo de memoria de la tabla, es
constante.
· Observaciones:
1. ---> &(ti) absurdo, se aplica a una variable.
2. ---> *ti  ti[0]; valor del int que comienza en ti.
 Apuntadores a Arreglos
Se pueden direccionar arreglos como si fueran apuntadores y apuntadores como si
fueran arreglos.
El nombre de un arreglo es un apuntador, contiene la dirección en memoria de comienzo
de la secuencia de elementos que forma el arreglo. Es un apuntador constante ya que
no se puede modificar, sólo se puede acceder para indexar a los elementos del arreglo.
- Ejemplo: Dada la siguiente declaración de un arreglo:
int lista[ 5 ] = { 10, 20, 30, 40, 50 };
Si se manda visualizar lista[ 0 ] se verá 10.
¿Qué sucederá si se manda visualizar *lista?
Memoria Como un nombre de un arreglo es un apuntador,
también se verá 10. Esto significa que:
lista [0] 10 * lista
lista + 0 apunta a lista[ 0 ]
[1] 20 * (lista + 1)
lista + 1 apunta a lista[ 1 ]
[2] 30 * (lista + 2)
lista + 2 apunta a lista[ 2 ]
[3] 40 * (lista + 3)
lista + 3 apunta a lista[ 3 ]
[4] 50 * (lista + 4)
lista + 4 apunta a lista[ 4 ]

Ejemplo de una tabla almacenada

Ej 5
en memoria
 Operador sizeof(tipo)

Operador sizeof(tipo):

Devuelve el número de bytes requerido para almacenar un

dato de un tipo C. El tipo de dato puede ser estándar de C o
definido por el programador.

Ejemplo:

typedef struct FCOMPLEX fcomplex;

=> sizeof(fcomplex)  8 bytes (fcomplex tiene 2 floats)

- Observación: sizeof(tipo) NO es una función, aunque su

sintaxis se parezca.
 Operador sizeof(tipo)

#include <stdio.h> /* imprimir los valores actuales */

main( ){
printf(“%p %p %p %p\n”, cp, ip, fp,
char *cp, ch; dp);
int *ip, i; /* ahora incrementarlos en uno */
float *fp, f; cp++;
double *dp, d; ip++;
cp = &ch; fp++;
ip = &i; dp++;
fp = &f; /* imprimir sus nuevos valores */
dp = &d; printf(“%p %p %p %p\n”, cp, ip, fp,
dp);
}
 Apuntadores a estructuras

• Un puntero también puede apuntar a

una estructura.

• Tal y como se declara un apuntador a

cualquier otro objeto se declara un
apuntador estructura
 Apuntadores a estructuras

struct persona{
char nombre[30 ] ;
int edad;
int altura;
int peso;
};
struct persona empleado = { “Amigo, Pepe” , 47, 182, 85};
struct persona *p; /* se crea un apuntador de estructura */
p = &empleado;
 Apuntadores a estructuras

• Se referencia una estructura utilizando el

apuntador estructura.
• Se utiliza el operador -> para acceder a un
miembro de ella.
• Nota:
• (.) Operador punto = operador miembro de la
estructura
• (->) Operador flecha = operador apuntador
de la estructura
 Apuntadores a estructuras

• Definición
– alumno *pfc;
pfc es un apuntador a un dato de tipo alumno
• Acceso a los miembros
– (*pfc).Re (No olvidar los paréntesis)
• Notación estándar:
– (*pfc).Re  pfc->Re
 Ejemplo
#include <stdio.h>
struct tpersona{
char nombre[30 ]; Se declara el tipo de estructura tpersona, que se asocia con el tipo
int edad; persona para facilidad de escritura. Un arreglo de esta estructura se
int altura; inicializa con campos al azar y se muestran por pantalla.
int peso;
};
typedef struct tpersona persona;
void MostrarPersona( persona * ptr );
main( ) void MostrarPersona( persona * ptr )
{ {
int i; printf("\nNombre: %s", ptr->nombre);
persona empleados[ ] = { printf("\tEdad: %d ", ptr->edad);
{ "Mortimer, Pepe", 47, 182, 85}, printf("\tAltura: %d ", ptr->altura);
"Garcia, Luis", 39, 170, 75, printf("\tPeso: %d\n", ptr->peso);
"Jiménez, Tomás", 18, 175, 80 }; }
persona *p;
p = empleados;
for (i = 0; i < 3; i++, p++)
MostrarPersona(p);
}
 Del ejemplo anterior

Al ejecutar el programa anterior se visualiza la salida siguiente:

Nombre: Mortimer, Pepe Edad: 47 Altura: 1.80 Peso: 85

Nombre: Garcia, Luis Edad: 39 Altura: 1.70 Peso: 75
Nombre: Jimenez, Tomás Edad: 18 Altura: 1.75 Peso: 80