Um caso interessante que acontece quando começamos a trabalhar com alocação dinâmica em c, é a preocupação em liberar a memória que é feita utilizando a função
free(). Contudo nem todos os programas que faremos terão um único ponteiro, podemos ter estruturas complexas com várias operações em seus dados, e como ter certeza nessas ocasiões de que a memória foi liberada? Para essas situações o uso da ferramenta
valgrind é o ideal. Esta ferramenta lhe permite ver quantos alocações foram feitas e quantas foram liberadas, além de várias outras aplicações veja mais clicando
aqui.
Para instalar a
valgrind em sua máquina digite no terminal:
sudo apt-get install valgrind
Agora, vamos fazer um teste com um programa básico. Digamos que criamos um ponteiro para inteiro e esquecemos de liberar no final da execução do programa, então no relatório da
valgrind ao final da execução terá um alerta de quantas alocações fizemos em byte e quanto dessas alocações foram liberadas, segue o código abaixo:
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char *argv[])
{
int *inteiro;
inteiro = (int*) malloc(sizeof(int));
*inteiro = 10;
printf("%d", *inteiro);
return 0;
}
Quando for compilar e rodar o seu programa utilize o seguinte comando para ativar a
valgrind:
gcc nomedoprograma.c -o nomedoprograma
valgrind ./nomedoprograma
Você receberá um relatório parecido com esse ao final do programa:
==5243== HEAP SUMMARY:
==5243== in use at exit: 4 bytes in 1 blocks
==5243== total heap usage: 1 allocs, 0 frees, 4 bytes allocated
==5243==
==5243== LEAK SUMMARY:
==5243== definitely lost: 4 bytes in 1 blocks
==5243== indirectly lost: 0 bytes in 0 blocks
==5243== possibly lost: 0 bytes in 0 blocks
==5243== still reachable: 0 bytes in 0 blocks
==5243== suppressed: 0 bytes in 0 blocks
==5243== Rerun with --leak-check=full to see details of leaked memory
==5243==
==5243== For counts of detected and suppressed errors, rerun with: -v
==5243== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Note que fizemos uma alocação de 4 bytes e não à liberamos, o que temos que fazer é corrigir o nosso programa para que libere o espaço alocado:
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char *argv[])
{
int *inteiro;
inteiro = (int*) malloc(sizeof(int));
*inteiro = 10;
printf("%d", *inteiro);
free(inteiro);
return 0;
}
E quando recompilar o seu programa verá um relatório diferente, mais otimista, com todos as alocações tendo seu espaço liberado após a execução:
==5350== HEAP SUMMARY:
==5350== in use at exit: 0 bytes in 0 blocks
==5350== total heap usage: 1 allocs, 1 frees, 4 bytes allocated
==5350==
==5350== All heap blocks were freed -- no leaks are possible
==5350==
==5350== For counts of detected and suppressed errors, rerun with: -v
==5350== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Esse foi um exemplo básico de como usar essa ferramenta, utilize-a em programas mais elaborados com várias estruturas que precisarão serem liberadas e deixe seus comentários sobre sua experiência com essa ferramenta. Até a próxima!
Valgrind: http://valgrind.org
