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 heap es una memory más grande pero más lenta que gestionas manualmente. Los objetos en el heap persisten hasta que los delete 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:

Stack	Heap
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 heap provoca memory leaks, 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 mediante la construcción de una clase simple Counter que realiza un seguimiento de 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 name private (string). Incluye un constructor que recibe un nombre e imprime "Creating: <name>", y un destructor que imprime "Destroying: <name>". Añade un método getName() para return el nombre del contador.
main.cpp: demuestra la allocation tanto en la pila como en el montón. Read un nombre desde input, después:
- Create un Counter allocated en la pila usando ese nombre
- Create un Counter allocated en el montón con el nombre "HeapCounter"
- Print ambos nombres de contador en el format "Stack: <name>" y "Heap: <name>"
- Delete el contador allocated en el montón para prevent un memory leak

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

Include 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;
}