Pilha vs heap em C: tempos de vida, ponteiros pendurados e quando usar cada um

Toda variável de um programa em C mora em algum lugar, e onde determina duas coisas que você não pode mudar depois: por quanto tempo ela sobrevive e quanto dela você pode ter. O C lhe dá três regiões de armazenamento, e escolher errado produz ou um travamento ou um vazamento. Esta página as apresenta e mostra o bug clássico que vem de errar os tempos de vida.

As três regiões

  enderecos altos
  +---------------------------+
  |  pilha                    |  locais, parametros, enderecos de retorno
  |    cresce para baixo  |   |  liberada automaticamente no retorno
  |                       v   |
  +---------------------------+
  |         (lacuna nao usada)|
  +---------------------------+
  |                       ^   |
  |    cresce para cima   |   |
  |  heap                     |  blocos de malloc / calloc / realloc
  +---------------------------+  liberados apenas por free()
  |  dados estaticos/globais  |  globais e statics, execucao inteira
  +---------------------------+
  |  codigo (text)            |  o codigo de maquina, somente leitura
  +---------------------------+
  enderecos baixos

• Armazenamento automático (a pilha) guarda parâmetros de função e locais não estáticas. Um bloco da pilha é reservado quando se entra numa função e liberado quando ela retorna. O tamanho é fixo em tempo de compilação.
• Armazenamento dinâmico (o heap) guarda tudo que vem de malloc, calloc e realloc. O tamanho é decidido em tempo de execução; o tempo de vida só termina no free.
• Armazenamento estático guarda globais e tudo declarado como static. Existe durante toda a execução do programa e é inicializado com zero antes de main começar.

Os endereços do diagrama são o arranjo usual, não uma garantia - a norma descreve tempos de vida, não leiaute.

Armazenamento automático em ação

#include <stdio.h>

void demo(void) {
    int local = 42;             /* criada aqui */
    int table[4] = {1, 2, 3, 4};

    printf("local = %d, table[0] = %d\n", local, table[0]);
}                               /* ambas liberadas aqui */

int main(void) {
    demo();
    demo();
    return 0;
}

Cada chamada a demo ganha um local novo e um table novo. Nada é liberado à mão, nada pode vazar, e a alocação custa uma única instrução que move o ponteiro de pilha. É por isso que locais comuns devem ser o seu padrão: são o armazenamento mais rápido e mais seguro que o C tem.

O detalhe é a chave de fechamento. Assim que ela é executada, aquela memória sumiu.

O ponteiro pendurado

Este é o bug que todo programador C escreve uma vez:

/* QUEBRADO: devolve o endereco de memoria que nao existe mais */
int *make_counter(void) {
    int count = 0;
    return &count;          /* count morre nesta chave */
}

int main(void) {
    int *p = make_counter();
    *p = 5;                 /* escrevendo num quadro de pilha morto */
    return 0;
}

&count era um endereço perfeitamente válido enquanto make_counter estava rodando. No retorno, aquele espaço da pilha é entregue à próxima função chamada, então p agora aponta para as variáveis locais de outra pessoa. Ler dá lixo; escrever as corrompe. GCC e Clang avisam sobre exatamente essa forma (-Wreturn-local-addr), então compile com avisos ligados.

O mesmo bug se disfarça com arrays, e aí o aviso muitas vezes não dispara:

#include <stdio.h>
#include <string.h>

/* Correto: o chamador fornece o armazenamento, entao ele sobrevive a chamada. */
void make_greeting(char *out, size_t size, const char *name) {
    snprintf(out, size, "Ola, %s!", name);
}

int main(void) {
    char message[64];
    make_greeting(message, sizeof message, "Ada");
    printf("%s\n", message);
    return 0;
}

A versão quebrada dessa função montaria o texto num char buf[64] local e faria return buf; - devolvendo o endereço de um buffer que deixa de existir no mesmo instante.

Três formas de corrigir

1. O chamador fornece o buffer (mostrado acima). Sem alocação, sem questão de propriedade, e o estilo mais comum nas bibliotecas de C. A função recebe o tamanho para poder se manter dentro dele.

2. Devolva memória do heap, e diga quem a libera.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Devolve uma string recem-alocada; o chamador deve libera-la. */
char *make_greeting(const char *name) {
    size_t size = strlen(name) + 16;
    char *out = malloc(size);
    if (out == NULL) {
        return NULL;
    }
    snprintf(out, size, "Ola, %s!", name);
    return out;
}

int main(void) {
    char *message = make_greeting("Ada");
    if (message == NULL) {
        return 1;
    }
    printf("%s\n", message);
    free(message);
    return 0;
}

O bloco do heap sobrevive à função por projeto - esse é todo o sentido da memória dinâmica. O custo é o comentário sobre a propriedade e o free do chamador.

3. Use armazenamento estático, quando um único buffer compartilhado for aceitável:

#include <stdio.h>

int *next_id(void) {
    static int id = 0;      /* uma instancia, vive pelo programa inteiro */
    id++;
    return &id;             /* seguro: armazenamento estatico nunca some */
}

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

O static dentro de uma função mantém o escopo da variável local enquanto lhe dá o tempo de vida do programa, então devolver o endereço dela é legal. A troca é que só existe uma dela: todo chamador a compartilha, o que torna esse padrão inutilizável em código com threads e surpreendente mesmo em código de thread única quando dois chamadores seguram o ponteiro ao mesmo tempo.

Tamanho: onde a pilha acaba

O espaço da pilha é pequeno e fixo. A thread principal costuma ganhar 1 MB no Windows e 8 MB no Linux; uma thread criada muitas vezes ganha bem menos. O heap é limitado pela memória disponível do sistema.

void bad(void) {
    int huge[1000000];      /* ~4 MB de pilha - provavelmente trava na entrada */
    huge[0] = 1;
}

Não há diagnóstico e não há NULL para verificar: o programa simplesmente morre, normalmente com uma falha de segmentação, antes da primeira linha do corpo rodar. A versão no heap reporta a falha direito:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t n = 1000000;

    int *huge = malloc(n * sizeof *huge);
    if (huge == NULL) {
        fprintf(stderr, "nao consegui alocar %zu ints\n", n);
        return 1;
    }

    huge[0] = 1;
    huge[n - 1] = 2;
    printf("%d ... %d (%zu bytes)\n", huge[0], huge[n - 1], n * sizeof *huge);

    free(huge);
    return 0;
}

Recursão profunda esgota a pilha do mesmo jeito, um quadro de cada vez - uma função recursiva desgovernada é, na prática, a causa mais comum de estouro de pilha.

Custo e localidade

A alocação na pilha é uma operação aritmética num registrador. A alocação no heap é uma chamada de biblioteca que procura um bloco adequado, pode adquirir um lock e ocasionalmente pede mais memória ao sistema operacional. Num laço quente essa diferença é mensurável.

Os dados da pilha também são compactos e foram tocados recentemente, então tendem a estar em cache. Os blocos do heap podem estar espalhados. Nenhum desses fatos deve guiar um projeto sozinho - a correção do tempo de vida vem primeiro - mas entre dois projetos ambos corretos, o da pilha costuma ser o mais rápido.

Enxergando as regiões

Imprimir endereços torna o leiaute concreto. Os valores exatos mudam a cada execução (sistemas modernos os aleatorizam), mas o agrupamento fica visível:

#include <stdio.h>
#include <stdlib.h>

int global_value = 1;

int main(void) {
    static int static_value = 2;
    int local_value = 3;

    int *heap_value = malloc(sizeof *heap_value);
    if (heap_value == NULL) {
        return 1;
    }
    *heap_value = 4;

    printf("global: %p\n", (void *)&global_value);
    printf("static: %p\n", (void *)&static_value);
    printf("heap:   %p\n", (void *)heap_value);
    printf("local:  %p\n", (void *)&local_value);

    free(heap_value);
    return 0;
}

A global e a estática ficam lado a lado; o bloco do heap está em outro lugar; a local costuma estar longe das duas. Converta para void * no %p - é o que o especificador de formato exige.

Escolhendo

Use a pilha quando:

• o tamanho é conhecido em tempo de compilação,
• os dados só são necessários dentro desta função e das que ela chama,
• e é pequeno - alguns kilobytes, não megabytes.

Use o heap quando:

• o tamanho depende da entrada, de um arquivo ou de um cálculo,
• os dados precisam sobreviver à função que os criou,
• ou é grande o bastante para ameaçar o limite da pilha.

Use estático quando:

• exatamente uma instância deve existir para o programa inteiro,
• e compartilhá-la entre todos os chamadores é genuinamente correto.

O padrão é a pilha. Recorra ao heap quando uma das suas três razões se aplicar, e quando o fizer, siga as regras de propriedade em vazamentos de memória para que o bloco cujo tempo de vida você ganhou ainda seja liberado.

Dois bugs espelhados

Vale nomeá-los juntos, porque são a mesma pergunta de tempo de vida respondida de duas maneiras:

• Ponteiro pendurado - a memória morreu antes do ponteiro. Devolver &local, ou usar um ponteiro depois do free. O programa lê ou escreve num armazenamento que agora pertence a outra coisa.
• Vazamento de memória - o ponteiro morreu antes da memória. Perder a última referência a um bloco do malloc. Nada quebra imediatamente; o processo apenas cresce.

Os dois vêm de um descompasso entre por quanto tempo os dados precisam viver e em que região você os colocou. Decida o tempo de vida primeiro, e a região vem a reboque.