/assets/symbol.svg" type="image/svg+xml"> Sesión 25 · Punteros: uso y conceptos de memoria - Beatlech School

Sesión 25 · Punteros: uso y conceptos de memoria

21 de noviembre de 2026⏱ 6 min de lecturaProf. profesor

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ónNombreTipoValor
0x1000xint25
0x1004yint40
0x1008pint *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=99

Qué 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 = 25

Pistas

  • 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 → 105

Pistas

  • 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 8

Revisió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

  1. Cada variable tiene una dirección en memoria (&x).
  2. Un puntero guarda una dirección: int *p = &x;
  3. *p accede o modifica el valor apuntado.
  4. Nunca uses punteros sin inicializar.

Pregunta de cierre: ¿qué aprendí hoy que antes no podía explicar o programar?

Bitly

¡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.

Deja tu pregunta