Algorítmica II · Guía Interactiva de C++ Laboratorio de Memoria, Punteros y Estructuras
De datos agrupados a control directo de la RAM

Domina estructuras, pilas, punteros y funciones viendo cada línea ejecutarse en memoria

Aprender C++ falla cuando el código se lee como texto plano sin observar qué cambia dentro de la memoria RAM. Esta guía recorre paso a paso los cuatro bloques de Algorítmica II con simuladores interactivos: modifica los datos de entrada, avanza línea por línea y observa cómo se llenan los campos de un struct, cómo crece una pila LIFO, dónde apunta un puntero *p y cómo viajan los parámetros por referencia &.

Bloque 01 · Agrupación 11 Ejercicios de struct simple, arreglos y anidamiento
Bloque 02 · LIFO 5 Pilas dinámicas: palíndromos, binario y paréntesis
Bloque 03 · Direcciones 6 Punteros a enteros, cadenas char* y estructuras
Bloque 04 · Modularidad 8 Funciones con retorno, validación y referencia &
Módulo 01 · Estructuras de Datos (struct)

Agrupar variables heterogéneas bajo un solo registro con notación de punto

Un arreglo tradicional solo almacena datos del mismo tipo (todos int o todos double). Cuando un problema modela entidades reales —como un Empleado con id, nombre y salario, o un Evento que además contiene una Fecha— necesitamos un struct. En memoria, una estructura reserva un bloque contiguo que reúne todos sus campos en orden.

Al combinar estructuras con arreglos (Empleado emp[N]) o anidar una estructura dentro de otra (Evento.fechaEvento.dia), el operador punto (.) actúa como ruta de navegación desde la variable externa hasta el dato primitivo exacto.

Regla práctica al leer texto y números con cin Al combinar cin >> var con cin.getline(...), el salto de línea pendiente en el búfer hace que el siguiente getline lea una cadena vacía. Limpia el búfer con cin.ignore() antes de leer cadenas con espacios.
Anatomía de una estructura anidada en memoria Doble notación de punto: ev.fechaEvento.dia
Simulador C++ · Módulo 01

Ejecución paso a paso de Estructuras

Paso 1 / 1
ejercicio_5_evento.cpp struct anidado
Explicación de la línea actual

Memoria · Instancias struct RAM
Consola de salida (cout) stdout

            

Lista completa de ejercicios: Estructuras de Datos (11)

Haz clic para ver código C++, explicación y marcar progreso
Módulo 02 · Pilas (Last In, First Out)

Invertir secuencias y validar anidamientos con la disciplina LIFO

Una Pila es una estructura lineal donde todas las inserciones (push) y extracciones (pop) ocurren exclusivamente por un extremo llamado tope (pila). El último elemento que entra es el primero en salir.

En Algorítmica II se construye enlazando nodos dinámicos con un puntero al nodo inferior (Nodo *siguiente). Esta simple restricción resuelve problemas clásicos: invertir una palabra para probar si es palíndromo, recolectar restos de división binaria en orden inverso y comprobar si cada paréntesis abierto tiene su cierre correspondiente.

La regla de oro al desapilar Nunca ejecutes pop() sin verificar antes pila != NULL (o !pila.empty()). Intentar extraer de una pila vacía produce un error de acceso a memoria (Segmentation Fault) o indica un paréntesis de cierre sin apertura.
Dinámica de nodos enlazados (LIFO) Cada push() apunta al antiguo tope y actualiza pila
Simulador C++ · Módulo 02

Ejecución paso a paso de Pilas LIFO

Paso 1 / 1
ejercicio_3_palindromo.cpp LIFO
Explicación de la línea actual

Torre de la Pila (Tope arriba) Nodos dinámicos
Consola de salida (cout) stdout

            

Lista completa de ejercicios: Pilas (5)

Incluye implementación con nodos dinámicos en C++
Módulo 03 · Punteros (* y &)

Separar el valor guardado de su dirección exacta en memoria RAM

Toda variable declarada en C++ ocupa una dirección física en memoria. El operador de dirección (&num) obtiene ese domicilio hexadecimal, mientras que un puntero (int *dir_num) es una variable diseñada específicamente para guardar esa dirección.

Al aplicar el operador de indirección (*dir_num), saltamos desde la dirección hasta el contenido almacenado allí. Esto permite recorrer cadenas de caracteres con aritmética (p++ avanza byte por byte hasta hallar '\0') y manipular estructuras mediante el operador flecha (ptr->promedio).

Dos símbolos, tres significados distintos En la declaración (int *p), el asterisco indica que p es un puntero. En una expresión (*p = 10), el asterisco accede al valor apuntado. Por su parte, p->campo equivale exactamente a (*p).campo.
Relación entre variable, dirección y operador flecha dir_n == &num | *dir_n == num
Simulador C++ · Módulo 03

Ejecución paso a paso con Punteros y Direcciones

Paso 1 / 1
ejercicio_2_primo_puntero.cpp *ptr &
Explicación de la línea actual

Mapa de Direcciones en RAM Hexadecimal
Consola de salida (cout) stdout

            

Lista completa de ejercicios: Punteros (6)

Uso estricto de apuntadores y desreferencia
Módulo 04 · Funciones (Valor y Referencia)

Dividir algoritmos en subprogramas y devolver múltiples resultados con referencia &

Las funciones encapsulan una tarea concreta —calcular una potencia, verificar si un número es perfecto o convertir temperaturas— evitando repetir código en main(). Cada invocación crea un marco temporal en la pila de llamadas (Call Stack).

Cuando un parámetro se pasa por valor (int totalSeg), la función recibe una copia independiente. Cuando se pasa por referencia (int& horas), el parámetro actúa como alias directo de la variable original en main(), permitiendo modificar tres variables a la vez sin usar múltiples return.

Validación separada de la lógica Tal como exige el ejercicio del número perfecto y del factorial, separar una función lógica de validación (esPositivo(n)) mantiene limpia la función de cálculo y evita ciclos infinitos cuando el usuario ingresa datos negativos o cero.
Paso por valor vs. paso por referencia en el Call Stack Las referencias (&) escriben directamente en main()
Simulador C++ · Módulo 04

Ejecución paso a paso del Call Stack y Funciones

Paso 1 / 1
ejercicio_6_tiempo_ref.cpp Referencia &
Explicación de la línea actual

Pila de Llamadas (Call Stack) Marcos activos
Consola de salida (cout) stdout

            

Lista completa de ejercicios: Funciones (8)

Prototipos, retorno de valor, validación lógica y referencias
Síntesis · Criterio de diseño en C++

Qué herramienta elegir según la forma del problema

Mecanismo C++ Qué resuelve Operador clave Error frecuente a vigilar
Estructuras (struct) Agrupar atributos distintos de una entidad (ej. Alumno con Fecha o Promedio). var.campo
var.anidado.sub
Omitir cin.ignore() entre un entero y un cin.getline() en arreglos.
Pilas (LIFO) Invertir orden, evaluar simetría (palíndromos, paréntesis) o restos en orden inverso. push(pila, dato)
pop(pila, dato)
Desapilar sin comprobar pila != NULL o olvidar vaciar nodos creados con new.
Punteros (* y &) Conocer dirección física, recorrer cadenas char* o modificar estructuras por dirección. &var, *ptr
ptr->miembro
Dereferenciar un puntero sin inicializar o salirse del terminador nulo '\0'.
Funciones con & Modularizar algoritmos, validar entradas y devolver dos o más resultados simultáneos. tipo fn(T& ref)
return valor;
Pasar por valor cuando se espera modificar la variable original en main().