No artigo passado de nossa apostila de C, ensinamos o como alocar memória de uma maneira dinâmica, através da função malloc() da biblioteca stdlib.h

Agora vamos ensinar como liberar essa memória que foi previamente alocada, que é um bom hábito que evita um famoso problema, o vazamento de memória. E ao término do tutorial, vamos resolver um exercício que foi proposto no artigo passado, onde iremos mostrar o uso das funções malloc() e free().
Download do curso: Apostila C Progressivo
Entre no mercado de trabalho! Clique aqui e obtenha seu certificado de programação C!

Memory leak (vazamento de memória) em linguagem C A solução para este tipo de problema é simples, basta usar a função free(), que vai liberar o espaço de memória que foi previamente alocado. Assim como outras funções de alocação dinâmica de memória, esta função também está na biblioteca stdlib.h

Ela recebe um ponteiro, o que foi usado para receber o endereço do bloco de memória alocada, e não retorna nada.
Ou seja, sua sintaxe é bem simples:

free(ponteiro);

O grande problema reside na pergunta 'Onde liberar memória?'
Se seu projeto for mais simples, provavelmente só vai precisar liberar ao final de sua aplicação (embora a memória seja geralmente liberada após terminar um programa, é uma boa prática de programação sempre liberar o que foi alocado antes de sua aplicação terminar).

Mas, basicamente, devemos liberar a memória sempre que não formos mais usar o que foi alocado.
Isso geralmente acontece ao final das funções ou loopings que fazem pedidos de alocação de memória.

Como exemplo, podemos 'consertar' o exemplo de código passado, simplesmente colocando free(ptr) ao final da função.
Veja que agora ela pode rodar infinitamente, pois a memória alocada é liberada após seu 'uso'.

#include <stdio.h> #include <stdlib.h> void aloca() { int *ptr; ptr = (int *) malloc(100); free(ptr); } int main(void) { while(1) aloca(); return 0; }





A importância do bom gerenciamento de memória Como havíamos dito, usar alocação de memória fará sempre seus programas serem mais robustos e seguros, por isso indicamos que use sempre em seus projetos, mesmo nos mais simples. E obviamente, sempre libere a memória alocada após seu uso, pois o vazamento de memória é um problema muito comum, que certamente você irá se deparar, caso siga a profissão.

É um problema tão habitual, que atormenta tanto os programadores, que existem até ferramentas para detectar os 'leaks memory'. Muitas vezes isto ocorre não por um erro, mas sim por um ataque.
Os anti-vírus, por exemplo, estão sempre gerenciando o uso da memória dos computadores que protegem, pois é um tipo de ataque comum, consumir toda a memória de um sistema, para travá-lo e tirá-lo do ar.

Se isso pode ocorrer em máquinas boas e modernas, imagine para quem trabalha com microcontroladores, por exemplo, que muitas vezes possuem apenas alguns poucos kilobytes de memória. Não é à toa que engenheiros de computação que trabalham com hardware estão sempre preocupados com a maneira na qual usam a memória de seus projetos.

Linguagens de programação de alto nível, como o Java, geralmente fazem de maneira 'automática' esse gerenciamento de memória. Geralmente funciona de maneira razoável, raramente funciona de maneira perfeita.
O ideal, para garantir que seu aplicativo seja sempre o mais confiável, robusto, seguro e rápido, só mesmo gerenciando 'na mão'.

Como diz o ditado: Se quer algo bem feito, faça-o você mesmo.

Alocação de memória, free() e segurança Embora o ensino da alocação e liberação de memória seja comum em vários livros e cursos, algumas coisas passam batido, principalmente no que se refere à segurança de uma aplicação.

Vamos mostrar agora uma maneira bem comum de explorar falhas através dos ponteiros.
Vamos criar um programa simples, que irá pedir uma senha e armazenar num local que foi previamente alocado.
Então você usa essa senha como quiser, e como é um bom programador, irá usar a free() para liberar a memória que foi usada, até mesmo por questões de segurança.

Porém, ao contrário do que muitos pensam (e aí que mora o perigo), ao liberar a memória você não vai apagar os dados existentes nela, você vai apenas dizer ao seu computador "Hey, esse bloco de bytes aqui, já usei, então você pode pegar para fazer outra coisa".

Mas as informações ainda estão lá. E como obter o que tem lá?
Através do ponteiro que ainda aponta para lá. Ou seja, a free() não vai mudar o endereço armazenado no ponteiro, ele ainda vai continuar apontando para sua senha mesmo após aquele bloco de memória ter sido liberado.

Veja o código do programa:

#include <stdio.h> #include <stdlib.h> int main(void) { char *senha; senha = (char *) malloc(21*sizeof(char)); printf("Digite sua senha [ate 20 caracteres]: "); scanf("%[^\n]s", senha); printf("Senha: %s\n", senha); printf("Endereço antes da free(): %d\n", &senha); free(senha); printf("Endereço depois da free(): %d\n", &senha); return 0; }
O resultado:
[Image]
Ou seja, o ponteiro maroto continua apontando pro local da memória que está minha senha, e alguém poderá usar de uma maneira bem maléfica caso eu não tenha gravado outra coisa por cima desse bloco de memória. Como nos proteger, então?

Uma boa prática de segurança é que sempre que for 'liberar' seus ponteiros, fazer eles apontarem para NULL.
Ou seja, faça:
ptr=NULL;

Sempre que usar a free(), pois embora tenha liberado a memória para outro uso, o ponteiro continuará apontando para aquele endereço de memória.
Assim, o ponteiro não vai mais te dedurar.

Exercício resolvido: Usando malloc() e free() No tutorial passado de nosso curso, passamos o seguinte exercício:
Crie um programa que calcula a média de uma quantidade qualquer (informada pelo usuário) de números.
O programa deve armazenas esses números em um vetor. Depois, use esse vetor para mostrar todos os números e mostrar a média dele.
Use alocação dinâmica de memória para colocar os números no vetor. Não desperdice memória.

Vamos resolvê-lo agora para ilustrar o uso da malloc() e da free().
Na main(), o programa inicia um looping, que só para se o usuário digitar 0.

Neste looping é pedido um número inteiro, que será o tanto de números que o usuário vai digitar.
Após ele fornecer essa informação, passamos ela para a função aloca() que vai alocar dinamicamente um vetor de inteiros, com o número de elementos exato que o usuário digitou, e retornar o endereço desse espaço alocado.

Esse endereço é armazenado no ponteiro *numeros, da main().
Em seguida, mandamos esse vetor e o número de elementos para a função media(), que irá calcular a média de todos os elementos deste vetor e retornar esse float (a média de inteiros pode ser um número decimal).
Também mandamos os mesmos argumentos para a função exibe(), que irá mostrar os números digitados.

Após cada iteração do laço while, devemos liberar a memória que está apontado pelo ponteiro *numeros, senão fizermos isso a função aloca() vai alocar um espaço diferente de memória a cada iteração, consumindo a memória aos poucos.

#include <stdio.h> #include <stdlib.h> int *aloca(int num) { int count, *numbers; numbers = (int *)malloc(num*sizeof(int)); for(count=0 ; count < num ; count++) { printf("Numero [%d]: ", count+1); scanf("%d", &numbers[count]); } return numbers; } float media(int *numbers, int num) { float media=0.0; int count; for(count=0 ; count<num ; count++) media += numbers[count]; return media/num; } void exibe(int *numbers, int num) { int count; for(count=0 ; count < num ; count++) printf("%3d", numbers[count]); } int main(void) { int num=1, *numeros; while(num) { printf("Media de quantos numeros [0 para sair]: "); scanf("%d", &num); if(num > 0) { numeros = aloca(num); exibe(numeros,num); printf("\nA media destes numeros eh: %.2f\n", media(numeros, num) ); free(numeros); } } return 0; }

Esse programa calcula a média de 1, 2, 10, mil ou 1 milhão de números.
E o melhor, só aloca 1, 2, 10, mil ou exatos 1 milhão de bytes, nem um a mais. Extramente econômico, não deixa seu computador 'lerdo' por consumir memória demais, o que é um grande problema ocasionado por péssimos programadores.

A Wikipedia possui um excelente artigo sobre Memory Leak.