Semana 13 · Unidad 4: Punteros, Estructuras y Archivos
Objetivo: Interpretar direcciones de memoria y usar punteros básicos en C++.
Objetivo y ruta de la sesión
Objetivo de aprendizaje
Interpretar direcciones de memoria y usar punteros básicos en C++.
En esta clase trabajaremos
Uso de punteros; variables, direcciones de memoria y referencias.
Ruta de la sesión (120 min)
10′ · Activación de conocimientos
35′ · Teoría y ejemplos guiados
55′ · Práctica y ejercicios en clase
10′ · Cierre y explicación del deber
Activación: pregunta de entrada
PREGUNTA DE ENTRADA
Tu casa tiene una dirección y adentro vive una familia. Si alguien tiene tu dirección, ¿puede llegar a tu casa? ¿Qué sería la «dirección» de una variable?
Para pensar y compartir
1. Escribe tu respuesta en 1 minuto.
2. Compárala con la de tu compañero.
3. Compartan una idea con la clase.
Memoria, variables y direcciones
La memoria es una secuencia de celdas numeradas: cada una tiene una dirección.
Una variable ocupa una o más celdas y tiene un nombre, un tipo, un valor y una dirección.
El operador & devuelve la dirección de una variable.
cout << &x muestra la dirección (en hexadecimal).
int x = 25;
cout << "valor: " << x << endl;
cout << "direccion: " << &x << endl;Representación en memoria (ejemplo)
| Dirección | Nombre | Tipo | Valor |
|---|---|---|---|
| 0x1000 | x | int | 25 |
| 0x1004 | y | int | 40 |
| 0x1008 | p | int * | 0x1000 (apunta a x) |
p guarda la dirección de x: decimos que «p apunta a x».
Punteros: variables que guardan direcciones
Un puntero es una variable cuyo valor es la dirección de otra variable.
Se declara con *: int *p; (puntero a int).
p = &x; guarda en p la dirección de x.
*p (desreferencia) accede al valor al que apunta.
int x = 25;
int *p;
p = &x; /* p apunta a x */
cout << *p; /* 25 */
*p = 40; /* cambia x */
cout << x; /* 40 */Un puntero modifica la variable original
#include <iostream>
using namespace std;
int main()
{
int a = 10, b = 20;
int *p = &a;
cout << "a=" << a << ", *p=" << *p << endl;
*p = *p + 5;
cout << "a=" << a << endl;
p = &b; /* ahora apunta a b */
*p = 99;
cout << "a=" << a << " b=" << b << endl;
return 0;
}a=10, *p=10
a=15
a=15 b=99Qué observar
- *p y a son el mismo dato.
- Un puntero puede cambiar de objetivo.
- Modificar *p modifica la variable apuntada.
Errores frecuentes: detéctalos antes de que ocurran
int *p;
*p = 5;p no está inicializado: apunta a una dirección desconocida. Puede cerrar el programa.
int x = 3;
int *p = x;Falta &: se intenta guardar el valor 3 como dirección. Debe ser p = &x.
int *p = &x;
cout << p;Muestra la dirección, no el valor. Para el valor usa *p.
float f = 1.5;
int *p = &f;El tipo del puntero debe coincidir con el de la variable apuntada.
Ejercicio: Dirección y valor de variables
EN CLASE · Básico
Declara tres variables (int, float, char), muestra el valor y la dirección de cada una. Después crea un puntero a la variable entera y muestra *p.
x = 25 dir = 0x7ffe...
*p = 25Pistas
- cout << &x muestra la dirección; con char usa (void*)&c.
- Un puntero por tipo: int *p;
- p = &x;
Solución: Dirección y valor de variables
int x = 25; float f = 1.5; char c = 'Z';
int *p = &x;
cout << "x = " << x << " dir = " << (void*)&x << endl;
cout << "f = " << fixed << setprecision(1) << f
<< " dir = " << (void*)&f << endl;
cout << "c = " << c << " dir = " << (void*)&c << endl;
cout << "*p = " << *p << endl;Revisión
- Las direcciones dependen del sistema.
- Observa la separación: 4 bytes por int, 1 por char.
- p y &x muestran la misma dirección.
Ejercicio: Modificar una variable con un puntero
EN CLASE · Básico
Lee un entero n. Con un puntero, duplica su valor y muestra el resultado. Luego haz que el puntero apunte a otra variable m y súmale 100.
n = 7 → 14
m = 5 → 105Pistas
- p = &n; *p = *p * 2;
- p = &m; *p += 100;
- Muestra n y m al final.
Solución: Modificar una variable con un puntero
int n, m;
int *p;
cin >> n >> m;
p = &n;
*p = *p * 2;
p = &m;
*p += 100;
cout << "n = " << n << " m = " << m << endl;Revisión
- Un puntero puede reutilizarse.
- *p += 100 equivale a m = m + 100.
- Sin cambiar n ni m directamente.
Ejercicio: Traza con punteros
EN CLASE · Reto
- Predice la salida:
- int a = 3, b = 8;
- int *p = &a, *q = &b;
- *p = *p + *q;
- q = p;
- *q = *q * 2;
- cout << a << » » << b;
Haz un dibujo de cajas y flechas.
Pistas
- Paso 1: a = 3 + 8 = 11.
- q = p → q apunta a a.
- *q = 22 modifica a.
Solución: Traza con punteros
Paso a paso:
1. a = 3, b = 8, p→a, q→b
2. *p = *p + *q → a = 3 + 8 = 11
3. q = p → q apunta a a
4. *q = *q * 2 → a = 22
Salida: 22 8Revisión
- Las flechas ayudan a seguir los punteros.
- b nunca cambia: q dejó de apuntar a b.
- Entrenar la traza evita errores.
Verificación rápida (5 min)
1. ¿Qué devuelve &x?
- A) El valor de x
- B) La dirección de x
- C) El tipo de x
- D) Nada
2. Si p = &x, ¿qué es *p?
- A) La dirección de p
- B) El valor de x
- C) Un error
- D) El tipo
3. int *p; significa…
- A) p es un entero
- B) p es un puntero a entero
- C) p es una constante
- D) p es un arreglo
Respuestas y justificación
Respuesta B · 1. La dirección de x & es el operador «dirección de».
Respuesta B · 2. El valor de x * desreferencia: accede al valor apuntado.
Respuesta B · 3. p es un puntero a entero p guarda direcciones de variables int.
Actividad y deber
ACTIVIDAD EN CLASE
Operadores & y *; declaración de punteros; asignación de direcciones; lectura/modificación mediante desreferenciación.
DEBER
Tarea 25 – Direcciones y punteros
Crear 4 ejercicios que muestren dirección y valor de variables y que modifiquen un valor mediante un puntero.
Entregable: Archivo .cpp + captura de ejecución.
Qué nos llevamos hoy
- Cada variable tiene una dirección en memoria (&x).
- Un puntero guarda una dirección: int *p = &x;
- *p accede o modifica el valor apuntado.
- Nunca uses punteros sin inicializar.
Pregunta de cierre: ¿qué aprendí hoy que antes no podía explicar o programar?

¡Buen trabajo! Llegaste al final de esta clase. Repasa los ejemplos, haz la tarea y, si tienes dudas, déjalas en los comentarios. — Bitly
💬 Preguntas y comentarios
¿Algo no quedó claro? Pregunta aquí y te respondo.