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 de funções ficam aqui e são automaticamente destruídas 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 delete 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
allocation rápida	allocation mais lenta
Tamanho limitado	Grande capacidade
Limpeza automática cleanup	cleanup Manual necessário
Objetos de tamanho fixo	Objetos de tamanho dinâmico

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

Esquecer de delete a memória do 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 da pilha e a memória Heap construindo uma simples classe Counter que acompanha como os objetos são criados e destruídos.

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

Counter.h: define uma classe Counter com um atributo privado name (string). Inclua um constructor que recebe um nome e prints "Creating: <name>", e um destructor que prints "Destroying: <name>". Adicione um getName() method para retornar o nome do contador.
main.cpp: demonstra a allocation tanto na pilha quanto no Heap. Read um nome do input e, então:
- Create um Counter alocado na pilha usando esse nome
- Create um Counter alocado no Heap com o nome "HeapCounter"
- Print ambos os nomes dos contadores no formato "Stack: <name>" e "Heap: <name>"
- Delete o contador alocado no Heap para prevent um vazamento de memory

Observe como as mensagens do constructor e do destructor aparecem em ordens diferentes, dependendo de quando você cria e delete cada objeto. O objeto da pilha será automatically destruído quando main() terminar, enquanto o objeto do Heap deve ser explicitamente deletado.

Faça include do 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;
}