Memoria Stack vs Heap

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 12 de 104.

Los programas de C++ utilizan dos regiones principales de memoria: la pila y el heap. Comprender dónde viven tus objetos es fundamental para escribir código eficiente y sin errores.

La pila es memoria rápida y automática. Las variables declaradas dentro de las funciones viven aquí y se destruyen automáticamente cuando salen de ámbito.

void example() {
    int x = 10;           // Asignación en la pila
    Player player;        // Asignación en la pila - destruido automáticamente
}   // x y player se destruyen aquí

El montón es una memoria más grande pero más lenta que administras manualmente. Los objetos en el montón persisten hasta que los eliminas explícitamente.

void example() {
    Player* player = new Player();  // Asignación en el heap
    // player existe hasta que se elimine
    delete player;                   // Se requiere limpieza manual
}

Diferencias clave:

Pila	Montón
Asignación rápida	Asignación más lenta
Tamaño limitado	Gran capacidad
Limpieza automática	Se necesita limpieza manual
Objetos de tamaño fijo	Objetos de tamaño dinámico

Usa asignación en la pila para objetos pequeños y de corta duración. Usa asignación en el montón cuando los objetos deban sobrevivir a su ámbito o cuando su tamaño se determine en tiempo de ejecución.

Olvidar eliminar la memoria del montón provoca fugas de memoria, una fuente común de errores en los programas de C++.

Desafío

Fácil

Exploremos la diferencia entre la memoria de la pila y la memoria del montón construyendo una clase Counter sencilla que registre cómo se crean y destruyen los objetos.

Crearás dos archivos para organizar tu código:

Counter.h: Define una clase Counter con un atributo privado name (cadena). Incluye un constructor que reciba un nombre e imprima "Creating: <name>", y un destructor que imprima "Destroying: <name>". Añade un método getName() que devuelva el nombre del contador.
main.cpp: Demuestra la asignación en la pila y en el montón. Lee un nombre de la entrada y después:
- Crea un Counter asignado en la pila usando ese nombre
- Crea un Counter asignado en el montón con el nombre "HeapCounter"
- Imprime ambos nombres de contador con el formato "Stack: <name>" y "Heap: <name>"
- Elimina el contador asignado en el montón para evitar una fuga de memoria

Observa cómo los mensajes del constructor y del destructor aparecen en órdenes diferentes según cuándo crees y elimines cada objeto. El objeto de la pila se destruirá automáticamente cuando termine main(), mientras que el objeto del montón debe eliminarse explícitamente.

Incluye tu archivo de encabezado en main.cpp usando #include "Counter.h".

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Counter.h"

using namespace std;

int main() {
    // Lee el nombre de la entrada
    string inputName;
    cin >> inputName;

    // TODO: Crea un Counter asignado en la pila usando inputName

    // TODO: Crea un Counter asignado en el montón con el nombre "HeapCounter"

    // TODO: Print stack counter name in format "Stack: <name>"

    // TODO: Imprime el nombre del contador del montón en el formato "Heap: <name>"

    // TODO: Elimina el contador asignado en el montón para evitar una fuga de memoria

    return 0;
}