C++ Academy · Aula

Alocação na pilha

Entenda como funciona o armazenamento automático

Alocação na pilha é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Armazenamento automático

As variáveis locais vivem no armazenamento automático, normalmente chamado de pilha. Elas são criadas quando a execução entra em seu escopo e destruídas quando sai dele.

#include <iostream>

int main() {
    int x = 42;          // on the stack
    double pi = 3.14;    // on the stack
    std::cout << x << " " << pi << "\n";
}

A pilha cresce e diminui

Cada chamada de função empilha um quadro da pilha que contém suas variáveis locais. Quando a função retorna, o quadro é removido e as variáveis locais desaparecem — não é necessária nenhuma limpeza manual.

#include <iostream>

void greet() {
    int local = 7;          // pushed on call
    std::cout << local << "\n";
}                            // popped on return

int main() { greet(); }

Ordenação LIFO

A pilha segue a regra último a entrar, primeiro a sair. A variável local criada mais recentemente é a primeira a ser destruída quando o escopo termina.

#include <iostream>

int main() {
    int a = 1;
    {
        int b = 2;   // created after a
        std::cout << b << "\n";
    }                // b destroyed first
    std::cout << a << "\n";
}

Rápido e econômico

A alocação na pilha é extremamente rápida: basta mover o ponteiro da pilha. Não é necessário procurar memória livre nem manter registros, como acontece com a área de alocação dinâmica.

O escopo determina o tempo de vida

Um objeto da pilha permanece ativo somente dentro do bloco em que foi declarado. Blocos aninhados têm seu próprio escopo.

#include <iostream>

int main() {
    for (int i = 0; i < 3; ++i) {
        int square = i * i;   // recreated each iteration
        std::cout << square << "\n";
    }
}

Tamanho limitado

A pilha tem um tamanho fixo e limitado, geralmente de alguns megabytes. Alocar matrizes enormes na pilha pode causar uma falha por estouro da pilha.

// Risky: a large fixed array on the stack
int big[1000000];   // may overflow the stack

Retornar um endereço da pilha é um erro

Nunca retorne um ponteiro ou uma referência para uma variável local. Quando a função retorna, esse armazenamento deixa de existir e o ponteiro fica inválido.

int* bad() {
    int local = 5;
    return &local;   // BUG: local dies here
}

Passe objetos grandes por referência

Copiar objetos grandes para a pilha é um desperdício. Passe-os por const& para evitar a cópia e manter pequeno o uso da pilha.

#include <string>

void print(const std::string& s) {  // no copy
    // use s
}

Objetos da pilha não precisam de delete

Como o compilador gerencia automaticamente o tempo de vida deles, você nunca deve chamar delete em uma variável da pilha.

#include <iostream>

int main() {
    int n = 10;
    // delete &n;   // ERROR: not heap-allocated
    std::cout << n << "\n";
}

Matrizes na pilha

Matrizes de tamanho fixo e comprimento conhecido ficam na pilha e são liberadas automaticamente quando o escopo termina.

#include <iostream>

int main() {
    int values[3] = {10, 20, 30};
    for (int v : values) std::cout << v << "\n";
}

Quando preferir a pilha

Prefira a pilha para objetos pequenos e de curta duração cujo tamanho seja conhecido em tempo de compilação. Ela é mais rápida e se limpa sozinha — recorra à memória dinâmica apenas quando realmente precisar.

Verificação rápida

Teste sua compreensão da alocação na pilha.

Recapitulação

Você aprendeu que a alocação na pilha usa armazenamento automático vinculado ao escopo: as variáveis são criadas ao entrar e destruídas ao sair, na ordem LIFO. Ela é rápida, limpa-se sozinha e tem tamanho limitado. Nunca retorne endereços de variáveis locais e nunca use delete em objetos da pilha.

Perguntas Frequentes

A aula “Alocação na pilha” é grátis?

Sim — o texto completo de “Alocação na pilha” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Alocação na pilha”?

Entenda como funciona o armazenamento automático Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Alocação na pilha”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy