C Academy · Aula

Detectando vazamentos

Fundamentos de memcheck.

Detectando vazamentos é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 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 vazamento

Um vazamento de memória ocorre quando você aloca memória no HEAP com malloc, calloc ou realloc e perde todos os ponteiros para ela antes de chamar free.

O bloco permanece reservado, mas inacessível, até o processo terminar. Em programas de execução longa, os vazamentos se acumulam até que a memória se esgote.

Um vazamento mínimo

Este programa vaza um bloco de 40 bytes.

O ponteiro p é uma variável local. Quando main retorna, p desaparece, mas o bloco do HEAP para o qual ele apontava nunca é liberado.

#include <stdlib.h>

int main(void) {
    int *p = malloc(10 * sizeof(int));
    p[0] = 1;
    return 0; /* never free(p) */
}

Executando o memcheck

memcheck é a ferramenta padrão, portanto você pode omitir o nome da ferramenta.

Adicione --leak-check=full para obter um rastreamento da pilha para cada alocação vazada.

gcc -g -O0 -o leak leak.c
valgrind --leak-check=full ./leak

O resumo de LEAK

Ao terminar, o Valgrind imprime um LEAK SUMMARY. Para o programa acima, ele aparece aproximadamente assim:

definitely lost: 40 bytes in 1 blocks

O rastreamento aponta para o local exato da chamada de malloc, então você sabe precisamente qual alocação nunca foi liberada.

As quatro categorias de vazamento

O memcheck classifica a memória perdida em quatro categorias:

definitely lost — nenhum ponteiro permanece; é um vazamento verdadeiro
indirectly lost — só é alcançável por meio de um bloco definitely lost
possibly lost — resta apenas um ponteiro para o interior do bloco
still reachable — existe um ponteiro ao terminar, mas você nunca liberou o bloco

Definitely lost versus still reachable

definitely lost é a categoria urgente: esses bytes nunca podem ser recuperados enquanto o programa estiver em execução.

still reachable é menos grave. O bloco está vazado ao terminar, mas um ponteiro global ou estático ainda faz referência a ele; normalmente, trata-se de uma alocação única que você simplesmente não se preocupou em liberar.

Vazamentos indiretos

Quando você perde o início de uma estrutura encadeada, todos os nós ficam inacessíveis.

O início aparece como definitely lost e o restante como indirectly lost. Corrigir a causa raiz, o início perdido, recupera tudo.

struct Node { int v; struct Node *next; };

struct Node *make(void) {
    struct Node *h = malloc(sizeof *h);
    h->next = malloc(sizeof *h);
    h->next->next = NULL;
    return h;
}
/* if the caller drops the returned head, both nodes leak */

A versão corrigida

Libere o que você alocar. Esta versão não tem nenhum vazamento.

Sob o Valgrind, ela informa All heap blocks were freed -- no leaks are possible.

#include <stdlib.h>

int main(void) {
    int *p = malloc(10 * sizeof(int));
    p[0] = 1;
    free(p);
    return 0;
}

Contando alocações

Mesmo sem vazamentos, o HEAP SUMMARY mostra o quanto seu programa trabalhou:

total heap usage: 1 allocs, 1 frees, 40 bytes allocated

Quando o número de alocações e liberações coincide, você tem uma execução limpa. Uma diferença é a primeira pista de que algo escapou.

Exibindo blocos ainda alcançáveis

Por padrão, o memcheck não lista em detalhes os blocos still reachable. Para analisar também esses blocos, adicione:

--show-leak-kinds=all

Isso força um rastreamento para cada categoria, sendo útil quando você quer um programa que libere absolutamente tudo antes de terminar.

valgrind --leak-check=full --show-leak-kinds=all ./leak

Vazamentos em caminhos de erro

Os vazamentos mais sorrateiros ficam ocultos em caminhos de retorno antecipado. Aqui, se a segunda alocação falhar, o primeiro bloco vaza.

Os testes comuns raramente percorrem esses ramos, mas o memcheck os captura sempre que o caminho é executado. Sempre libere o que estiver sob sua responsabilidade antes de retornar em caso de erro.

char *a = malloc(100);
char *b = malloc(100);
if (!b) {
    /* bug: a is leaked here */
    return -1;
}
/* fix: free(a); before returning */

Verificação rápida

Escolha a categoria de vazamento que exige a atenção mais urgente.

Recapitulação

Agora você consegue detectar vazamentos com o memcheck:

Execute valgrind --leak-check=full ./prog em um binário compilado com -g
Leia o LEAK SUMMARY e o HEAP SUMMARY
Dê prioridade a definitely lost e depois rastreie os vazamentos indiretos até a raiz
Use --show-leak-kinds=all para analisar os blocos ainda alcançáveis

Em seguida: acesso inválido à memória.

Perguntas Frequentes

A aula “Detectando vazamentos” é grátis?

Sim — o texto completo de “Detectando vazamentos” é 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 “Detectando vazamentos”?

Fundamentos de memcheck. 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 2 de 4.

Quanto tempo leva a aula “Detectando vazamentos”?

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