Isso tem sido algo que me incomoda há muito tempo.
Todos nós somos ensinados na escola (pelo menos eu fui) que você DEVE libertar todos os indicadores que estão alocados. Estou um pouco curioso, porém, sobre o custo real de não liberar memória. Em alguns casos óbvios, como quando malloc
é chamado dentro de um loop ou parte de uma execução de encadeamento, é muito importante liberar para que não haja vazamentos de memória. Mas considere os dois exemplos a seguir:
Primeiro, se eu tiver código, é algo como isto:
int main()
{
char *a = malloc(1024);
/* Do some arbitrary stuff with 'a' (no alloc functions) */
return 0;
}
Qual é o resultado real aqui? Meu pensamento é que o processo morre e, em seguida, o espaço do heap se esgota, de modo que não há mal em perder a chamada free
(no entanto, reconheço a importância de tê-lo de qualquer maneira para fechamento, manutenção e boas práticas). Estou certo nesse pensamento?
Segundo, digamos que eu tenho um programa que funciona um pouco como um shell. Os usuários podem declarar variáveis como aaa = 123
e essas são armazenadas em alguma estrutura de dados dinâmica para uso posterior. Claramente, parece óbvio que você usaria alguma solução que chamaria alguma função * assign (hashmap, lista vinculada, algo assim). Para esse tipo de programa, não faz sentido nunca ser liberado após a chamada, malloc
porque essas variáveis devem estar presentes o tempo todo durante a execução do programa e não há uma boa maneira (que eu possa ver) de implementá-lo com espaço alocado estaticamente. É um projeto ruim ter um monte de memória alocada, mas liberada apenas como parte do processo que termina? Se sim, qual é a alternativa?
free(a)
realmente não faz nada para realmente liberar memória! Ele apenas redefine alguns indicadores na implementação libc do malloc, que monitora os pedaços de memória disponíveis dentro de uma grande página de memória mapeada (normalmente chamada de "heap"). Essa página ainda será liberada somente quando o programa terminar, não antes.