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.

Os programas em C++ usam duas regiões principais de memória: a pilha e o heap. Entender onde seus objetos ficam é crucial para escrever um código eficiente e livre de bugs.

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

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

A heap é uma memória maior, porém mais lenta, que você gerencia manualmente. Os objetos na heap persistem até que você os exclua explicitamente.

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

Principais diferenças:

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

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

Esquecer de excluir a memória da heap causa vazamentos de memória, uma fonte comum de bugs em programas C++.

Desafio

Fácil

Vamos explorar a diferença entre a memória de pilha e a memória heap construindo uma classe simples Counter que acompanha 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 recebe um nome e exibe "Creating: <name>", e um destrutor que exibe "Destroying: <name>". Adicione um método getName() para retornar o nome do contador.
main.cpp: Demonstre a alocação tanto na pilha quanto no heap. Leia um nome da entrada e, em seguida:
- Crie um Counter alocado na pilha usando esse nome
- Crie um Counter alocado no heap com o nome "HeapCounter"
- Exiba os dois nomes dos contadores no formato "Stack: <name>" e "Heap: <name>"
- Exclua o contador alocado no heap para evitar um vazamento de memória

Observe como as mensagens do construtor e do destrutor aparecem em ordens diferentes, dependendo de quando você cria e exclui cada objeto. O objeto na pilha será destruído automaticamente quando main() terminar, enquanto o objeto no heap precisa ser excluído explicitamente.

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

Experimente você mesmo

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

using namespace std;

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

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

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

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

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

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

    return 0;
}