C Academy · Aula

Vazamentos de memória

Encontre e evite vazamentos.

Vazamentos de memória é uma aula grátis de C Academy no CoddyKit. Esta é a aula 3 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 de memória

Um vazamento de memória ocorre quando você aloca memória na área dinâmica, mas nunca a libera e perde o único ponteiro para ela.

A memória continua reservada até o programa ser encerrado, desperdiçando recursos.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Perdendo o ponteiro

O vazamento clássico sobrescreve um ponteiro com uma nova alocação antes de liberar a antiga.

O primeiro bloco fica inacessível.

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

int main(void) {
    int *p = malloc(sizeof(int));
    free(p);
    p = malloc(sizeof(int));
    *p = 10;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Vazamentos em laços

Alocar dentro de um laço sem liberar a memória em cada iteração faz o vazamento crescer rapidamente.

A solução é liberar a memória antes que a próxima iteração sobrescreva o ponteiro.

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

int main(void) {
    for (int i = 0; i < 3; i++) {
        int *p = malloc(sizeof(int));
        *p = i;
        printf("%d ", *p);
        free(p);
    }
    printf("\n");
    return 0;
}

Retornos antecipados causam vazamentos

Um return antecipado depois de uma alocação pode ignorar a limpeza. Sempre libere a memória em todos os caminhos de saída.

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

int process(int bad) {
    int *p = malloc(sizeof(int));
    if (bad) {
        free(p);
        return -1;
    }
    *p = 42;
    int r = *p;
    free(p);
    return r;
}

int main(void) {
    printf("%d\n", process(0));
    return 0;
}

O padrão de limpeza com goto

Um único rótulo de limpeza alcançado por goto garante um só local para liberar tudo, evitando chamadas free duplicadas.

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

int main(void) {
    int rc = 1;
    int *p = malloc(sizeof(int));
    if (!p) goto done;
    *p = 7;
    printf("%d\n", *p);
    rc = 0;
done:
    free(p);
    return rc;
}

Associe cada alocação

A regra mais simples: para cada malloc, calloc ou realloc, deve haver exatamente um free correspondente.

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

int main(void) {
    char *a = malloc(8);
    char *b = calloc(4, sizeof(char));
    a[0] = 'x';
    printf("%c %d\n", a[0], b[0]);
    free(a);
    free(b);
    return 0;
}

Liberando alocações aninhadas

Se uma estrutura possui memória na área dinâmica, libere os ponteiros internos antes de liberar o bloco externo.

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

typedef struct {
    int *data;
} Box;

int main(void) {
    Box *b = malloc(sizeof(Box));
    b->data = malloc(3 * sizeof(int));
    b->data[0] = 1;
    printf("%d\n", b->data[0]);
    free(b->data);
    free(b);
    return 0;
}

Liberando uma matriz de ponteiros

Quando você aloca uma matriz de ponteiros e cada entrada é uma alocação própria, libere primeiro todas as entradas e depois a matriz.

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

int main(void) {
    int n = 3;
    int **rows = malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        rows[i] = malloc(2 * sizeof(int));
        rows[i][0] = i;
    }
    for (int i = 0; i < n; i++) free(rows[i]);
    free(rows);
    printf("freed all rows\n");
    return 0;
}

Disciplina de propriedade

Decida quem possui cada alocação e é responsável por liberá-la. Documente isso para que quem chama saiba se deve liberar um ponteiro retornado.

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

char *make_greeting(void) {
    char *s = malloc(6);
    s[0]='h'; s[1]='i'; s[2]='\0';
    return s;
}

int main(void) {
    char *g = make_greeting();
    printf("%s\n", g);
    free(g);
    return 0;
}

Ferramentas que encontram vazamentos

Ferramentas como Valgrind e AddressSanitizer identificam vazamentos rastreando cada alocação e mostrando quais nunca foram liberadas.

Elas são essenciais para verificar programas reais.

Um ciclo de vida de alocação limpo

Reunindo tudo: aloque, verifique, use, libere em todos os caminhos e defina o ponteiro como nulo. Isso mantém os programas livres de vazamentos.

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

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

Verificação rápida

Teste sua compreensão sobre vazamentos de memória.

Recapitulação

Você aprendeu a evitar vazamentos de memória:

Associe cada alocação a exatamente um free.
Libere a memória em todos os caminhos de saída, incluindo retornos antecipados e erros.
Libere primeiro as alocações internas de estruturas aninhadas e de matrizes de ponteiros.
Defina claramente a propriedade e use ferramentas como Valgrind para verificar.

Perguntas Frequentes

A aula “Vazamentos de memória” é grátis?

Sim — o texto completo de “Vazamentos de memória” é 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 “Vazamentos de memória”?

Encontre e evite vazamentos. 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 3 de 4.

Quanto tempo leva a aula “Vazamentos de memória”?

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