C Academy · Aula

Evitando estouro de pilha

Mantenha a recursão limitada.

Evitando estouro de pilha é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 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.

O que é um Estouro da Pilha?

A pilha de chamadas tem tamanho limitado. Cada chamada de função usa parte dela para parâmetros e variáveis locais.

Se a recursão for profunda demais, a pilha fica cheia e o programa falha com um estouro da pilha.

Caso-Base Ausente

A causa mais comum é um caso-base que nunca é alcançado. Isso cria um ciclo infinito e estoura a pilha.

Não execute esse tipo de função; estude por que ela falha.

int broken(int n) {
    /* no base case: never stops */
    return broken(n + 1);
}

Argumento que não Diminui

Mesmo com um caso-base, o argumento precisa avançar em direção a ele. Aqui n aumenta, portanto nunca chega a 0.

Verifique sempre se cada chamada se aproxima da condição de parada.

int oops(int n) {
    if (n == 0) return 0;
    return oops(n + 1); /* wrong direction */
}

Uma Versão Correta

Corrigir a direção faz a função terminar. Agora n diminui em direção ao caso-base 0.

#include <stdio.h>

int good(int n) {
    if (n == 0) return 0;
    return n + good(n - 1);
}

int main(void) {
    printf("%d\n", good(10));
    return 0;
}

Os Limites de Profundidade são Reais

Mesmo uma recursão correta pode estourar a pilha se for muito profunda. Chamar uma função em milhões de níveis de profundidade pode exceder a pilha, que geralmente tem apenas alguns megabytes.

Para profundidades enormes, prefira a iteração.

Converta Recursão Profunda em um Laço

Se a profundidade da recursão crescer com o tamanho da entrada, troque-a por um laço. Isso evita empilhar milhares de quadros.

O laço abaixo soma de 1 até um n grande com segurança e memória constante.

#include <stdio.h>

int main(void) {
    long total = 0;
    for (int i = 1; i <= 1000000; i++)
        total += i;
    printf("%ld\n", total);
    return 0;
}

Reduza a Profundidade com Divisão e Conquista

Dividir o trabalho ao meio mantém a profundidade pequena. Somar um intervalo dividindo-o ao meio faz a profundidade crescer como o logaritmo do tamanho, em vez de linearmente.

long range_sum(int lo, int hi) {
    if (lo == hi) return lo;
    int mid = (lo + hi) / 2;
    return range_sum(lo, mid) + range_sum(mid + 1, hi);
}

Cuidado com Vetores Locais Grandes

Variáveis locais Big tornam cada quadro heavy, fazendo a pilha encher mais rapidamente.

Evite declarar vetores grandes dentro de uma função recursiva; passe ponteiros ou use o heap.

void heavy(int n) {
    int buffer[10000]; /* big frame each call */
    if (n == 0) return;
    heavy(n - 1);
}

Use um Acumulador

Passar um total corrente como acumulador mantém cada quadro pequeno e dá à recursão uma estrutura de cauda.

Assim, alguns compiladores podem reutilizar um único quadro.

#include <stdio.h>

long sum_acc(int n, long acc) {
    if (n == 0) return acc;
    return sum_acc(n - 1, acc + n);
}

int main(void) {
    printf("%ld\n", sum_acc(100, 0));
    return 0;
}

Uma Lista de Verificação de Segurança

Antes de confiar em uma função recursiva, verifique:

1. Existe um caso-base?
2. Cada chamada avança em direção a ele?
3. A profundidade pode ser enorme para uma entrada grande?

Se a profundidade puder crescer descontroladamente, use um laço.

Testando com Entradas Pequenas

Sempre teste a recursão primeiro com entradas minúsculas que você possa verificar manualmente.

Se os casos pequenos funcionarem e a profundidade permanecer limitada, você poderá aumentar a escala com confiança.

Verificação rápida

Identifique a correção mais segura.

Recapitulação

O estouro da pilha ocorre quando a recursão é profunda demais ou nunca termina. Sempre forneça um caso-base alcançável, reduza o argumento a cada chamada, mantenha os quadros leves e mude para a iteração quando a profundidade puder crescer com o tamanho da entrada.

Perguntas Frequentes

A aula “Evitando estouro de pilha” é grátis?

Sim — o texto completo de “Evitando estouro de 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 “Evitando estouro de pilha”?

Mantenha a recursão limitada. 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 4 de 4.

Quanto tempo leva a aula “Evitando estouro de 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