C Academy · Aula

Liberando memória e evitando vazamentos

Faça a limpeza corretamente.

Liberando memória e evitando vazamentos é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 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.

Todo malloc precisa de um free

A memória da heap permanece reservada até que o senhor a libere com free. Se perder o único ponteiro para um bloco sem liberá-lo, essa memória ficará vazada.

Os vazamentos se acumulam com o tempo e podem esgotar a memória em programas de execução prolongada.

int *a = malloc(100 * sizeof(*a));
/* ... use a ... */
free(a);

O que free realmente faz

free(p) devolve o bloco ao alocador para que ele possa ser reutilizado. Ele não altera o valor de p.

Depois de free, p ainda aponta para o endereço antigo, que agora é inválido. Acessá-lo resulta em comportamento indefinido.

free(p);
/* p is now a dangling pointer */

A armadilha do ponteiro pendente

Usar um ponteiro depois de liberá-lo é um erro de uso após liberação. Isso pode parecer funcionar e depois corromper dados ou causar uma falha de maneira imprevisível.

Uma proteção simples é definir o ponteiro como NULL imediatamente após a liberação.

free(a);
a = NULL;   /* now misuse is a clean NULL deref, easier to catch */

Liberar duas vezes é indefinido

Chamar free duas vezes para o mesmo bloco corrompe o estado interno do alocador e frequentemente causa uma falha.

Definir o ponteiro como NULL após a primeira liberação ajuda, pois free(NULL) é explicitamente seguro e não faz nada.

free(a);
a = NULL;
free(a);   /* free(NULL) is a harmless no-op */

Libere somente o que foi alocado com malloc

Passe para free somente um ponteiro obtido de malloc, calloc ou realloc.

Liberar o endereço de uma variável da pilha, um literal de string ou um ponteiro para o meio de um bloco resulta em comportamento indefinido.

int x = 5;
/* free(&x);   WRONG: x is on the stack */
int *p = malloc(sizeof(int));
free(p);        /* correct */

Vazamento causado por um retorno antecipado

Um vazamento comum ocorre quando o senhor aloca memória e depois segue por um caminho de erro que retorna antes de liberá-la. O bloco é perdido.

Certifique-se de que todo caminho de saída que seja proprietário da memória a libere primeiro.

int *a = malloc(n * sizeof(*a));
if (something_failed) {
    free(a);   /* don't forget this before returning */
    return -1;
}

Um programa limpo de alocação e liberação

Este programa aloca, usa e libera a memória em todos os caminhos, sem deixar vazamentos.

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

int main(void) {
    int n = 4;
    int *a = malloc(n * sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < n; i++) a[i] = i + 1;
    int sum = 0;
    for (int i = 0; i < n; i++) sum += a[i];
    printf("%d\n", sum);
    free(a);
    a = NULL;
    return 0;
}

Liberando alocações aninhadas

Se um bloco contiver ponteiros para outros blocos, libere primeiro os blocos internos e depois o externo.

Liberar o bloco externo primeiro faria os endereços dos blocos internos serem perdidos, causando vazamento deles.

for (size_t i = 0; i < rows; i++)
    free(grid[i]);   /* free each row first */
free(grid);          /* then the array of pointers */

Um proprietário por bloco

Decida qual parte do seu código é proprietária de cada alocação e é responsável por liberá-la.

Se dois ponteiros referenciarem o mesmo bloco e ambos o liberarem, ocorrerá uma liberação dupla. Uma propriedade bem definida evita isso.

Detectando vazamentos com ferramentas

O senhor não precisa encontrar vazamentos apenas observando o código. Ferramentas como valgrind ou AddressSanitizer relatam vazamentos e liberações inválidas com números de linha.

Compile com -g e execute usando a ferramenta para ver exatamente o que não foi liberado.

/* gcc -g -fsanitize=address prog.c && ./a.out */
/* or: valgrind --leak-check=full ./a.out */

Libere na ordem inversa da configuração

Um hábito confiável é liberar os recursos na ordem inversa àquela em que foram adquiridos, dentro de uma função que adquire vários recursos.

Isso acompanha a forma como as dependências foram construídas e mantém a limpeza previsível.

char *buf = malloc(64);
int  *idx = malloc(64 * sizeof(int));
/* ... use them ... */
free(idx);   /* free last-acquired first */
free(buf);

Verificação rápida

Teste sua compreensão sobre a liberação de memória.

Recapitulação

Associe cada alocação a exatamente um free, em todos os caminhos do código.

Evite ponteiros pendentes e liberações duplas definindo os ponteiros como NULL depois de liberá-los. Libere as alocações aninhadas começando pelas internas, atribua um proprietário a cada bloco e use valgrind ou AddressSanitizer para detectar vazamentos. Agora o senhor tem o conjunto completo de ferramentas para arrays dinâmicos.

Perguntas Frequentes

A aula “Liberando memória e evitando vazamentos” é grátis?

Sim — o texto completo de “Liberando memória e evitando 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 “Liberando memória e evitando vazamentos”?

Faça a limpeza corretamente. 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 4 de 4.

Quanto tempo leva a aula “Liberando memória e evitando 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