Memória Stack vs Heap

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 12 de 104.

Programas C++ usam duas regiões de memória principais: a stack e o heap. Entender onde seus objetos residem é crucial para escrever código eficiente e livre de bugs.

A stack é uma memória rápida e automática. Variáveis declaradas dentro de funções vivem aqui e são destruídas automaticamente quando saem de escopo.

void example() {
    int x = 10;           // Alocação na pilha
    Player player;        // Alocação na pilha - destruído automaticamente
}   // x e player são destruídos aqui

O heap é uma memória maior, porém mais lenta, que você gerencia manualmente. Objetos no heap persistem até que você os exclua explicitamente.

void example() {
    Player* player = new Player();  // Alocação no heap
    // player existe até ser deletado
    delete player;                   // Limpeza manual necessária
}

Principais diferenças:

Stack	Heap
Alocação rápida	Alocação mais lenta
Tamanho limitado	Grande capacidade
Limpeza automática	Necessita de limpeza manual
Objetos de tamanho fixo	Objetos de tamanho dinâmico

Use alocação na pilha para objetos pequenos e de vida curta. Use alocação no heap quando os objetos precisarem sobreviver ao seu escopo ou quando seu tamanho for determinado em tempo de execução.

Esquecer de liberar a memória heap causa vazamentos de memória (memory leaks), uma fonte comum de bugs em programas C++.

Desafio

Fácil

Vamos explorar a diferença entre a memória stack e heap construindo uma classe Counter simples que rastreia como os objetos são criados e destruídos.

Você criará dois arquivos para organizar seu código:

Counter.h: Defina uma classe Counter com um atributo privado name (string). Inclua um construtor que receba um nome e imprima "Creating: <name>", e um destruidor que imprima "Destroying: <name>". Adicione um método getName() para retornar o nome do contador.
main.cpp: Demonstre a alocação tanto na stack quanto na heap. Leia um nome da entrada e, em seguida:
- Crie um Counter alocado na stack usando esse nome
- Crie um Counter alocado na heap com o nome "HeapCounter"
- Imprima ambos os nomes dos contadores no formato "Stack: <name>" e "Heap: <name>"
- Delete o contador alocado na heap para evitar um vazamento de memória (memory leak)

Observe como as mensagens do construtor e do destruidor aparecem em ordens diferentes com base em quando você cria e deleta cada objeto. O objeto da stack será destruído automaticamente quando a função main() terminar, enquanto o objeto da heap deve ser explicitamente deletado.

Inclua seu arquivo de cabeçalho no main.cpp usando #include "Counter.h".

Folha de consulta

Programas C++ usam duas regiões principais de memória: a stack e o heap.

A stack é uma memória rápida e automática. Variáveis declaradas dentro de funções vivem aqui e são destruídas automaticamente quando saem de escopo:

void example() {
    int x = 10;           // Alocação na stack
    Player player;        // Alocação na stack - destruída automaticamente
}   // x e player são destruídos aqui

O heap é uma memória maior, porém mais lenta, que você gerencia manualmente. Objetos no heap persistem até que você os delete explicitamente:

void example() {
    Player* player = new Player();  // Alocação no heap
    // player existe até ser deletado
    delete player;                   // Limpeza manual necessária
}

Principais diferenças:

Stack	Heap
Alocação rápida	Alocação mais lenta
Tamanho limitado	Grande capacidade
Limpeza automática	Limpeza manual necessária
Objetos de tamanho fixo	Objetos de tamanho dinâmico

Use alocação na stack para objetos pequenos e de vida curta. Use alocação no heap quando os objetos precisarem sobreviver ao seu escopo ou quando seu tamanho for determinado em tempo de execução. Esquecer de deletar a memória do heap causa vazamentos de memória (memory leaks).

Experimente você mesmo

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

using namespace std;

int main() {
    // Lê o nome da entrada
    string inputName;
    cin >> inputName;

    // TODO: Criar um Counter alocado na stack usando inputName

    // TODO: Criar um Counter alocado na heap com o nome "HeapCounter"

    // TODO: Imprimir o nome do contador da stack no formato "Stack: <name>"

    // TODO: Imprimir o nome do contador da heap no formato "Heap: <name>"

    // TODO: Deletar o contador alocado na heap para evitar vazamento de memória

    return 0;
}