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 de memoria principales: la pila (stack) y el montículo (heap). Comprender dónde residen sus objetos es crucial para escribir código eficiente y libre de errores.

La pila (stack) es memoria rápida y automática. Las variables declaradas dentro de las funciones residen aquí y se destruyen automáticamente cuando salen de su ámbito (scope).

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

El heap es una memoria más grande pero más lenta que se gestiona manualmente. Los objetos en el heap 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:

Stack	Heap
Asignación rápida	Asignación más lenta
Tamaño limitado	Gran capacidad
Limpieza automática	Requiere limpieza manual
Objetos de tamaño fijo	Objetos de tamaño dinámico

Utilice la asignación en pila para objetos pequeños y de vida corta. Utilice la asignación en el montículo cuando los objetos necesiten sobrevivir a su ámbito o cuando su tamaño se determine en tiempo de ejecución.

Olvidar liberar la memoria del heap 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 stack y heap construyendo una clase Counter simple que rastrea 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 (string). Incluye un constructor que reciba un nombre e imprima "Creating: <name>", y un destructor que imprima "Destroying: <name>". Añade un método getName() para devolver el nombre del contador.
main.cpp: Demuestra la asignación tanto en stack como en heap. Lee un nombre de la entrada, luego:
- Crea un Counter asignado en el stack usando ese nombre
- Crea un Counter asignado en el heap con el nombre "HeapCounter"
- Imprime ambos nombres de los contadores en el formato "Stack: <name>" y "Heap: <name>"
- Elimina el contador asignado en el heap para evitar una fuga de memoria

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

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

Hoja de referencia

Los programas en C++ utilizan dos regiones de memoria principales: la pila (stack) y el montículo (heap).

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

void example() {
    int x = 10;           // Stack allocation
    Player player;        // Stack allocation - destroyed automatically
}   // x and player are destroyed here

El montículo es una memoria más grande pero más lenta que se gestiona manualmente. Los objetos en el montículo persisten hasta que los eliminas explícitamente:

void example() {
    Player* player = new Player();  // Heap allocation
    // player exists until deleted
    delete player;                   // Manual cleanup required
}

Diferencias clave:

Pila (Stack)	Montículo (Heap)
Asignación rápida	Asignación más lenta
Tamaño limitado	Gran capacidad
Limpieza automática	Requiere limpieza manual
Objetos de tamaño fijo	Objetos de tamaño dinámico

Utiliza la asignación en la pila para objetos pequeños y de vida corta. Utiliza la asignación en el montículo cuando los objetos necesiten sobrevivir a su ámbito o cuando su tamaño se determine en tiempo de ejecución. Olvidar eliminar la memoria del montículo provoca fugas de memoria (memory leaks).

Pruébalo tú mismo

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

using namespace std;

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

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

    // TODO: Crear un Counter asignado en el montículo con el nombre "HeapCounter"

    // TODO: Imprimir el nombre del contador de la pila en el formato "Stack: <name>"

    // TODO: Imprimir el nombre del contador del montículo en el formato "Heap: <name>"

    // TODO: Eliminar el contador asignado en el montículo para evitar fugas de memoria

    return 0;
}