Menu
Coddy logo textTech

Liberando Memória com free()

Parte da seção Logic & Flow do Journey de C da Coddy — lição 35 de 63.

Quando você aloca memória dinamicamente usando malloc(), essa memória permanece alocada até que você a libere explicitamente. A função free() é a sua ferramenta para retornar a memória alocada dinamicamente de volta ao sistema quando você terminar de usá-la.

A função free() recebe um argumento: um ponteiro para o bloco de memória que você deseja desalocar. Este deve ser o mesmo ponteiro que foi retornado por malloc() (ou funções relacionadas como calloc()).

#include <stdlib.h>

int *ptr = (int*)malloc(sizeof(int));  // Alocar memória
*ptr = 42;  // Usar a memória
free(ptr);  // Liberar a memória quando terminar

Deixar de chamar free() cria o que é conhecido como um vazamento de memória. A memória alocada permanece reservada pelo seu programa, mesmo que você não a esteja mais usando. Em programas de longa execução ou programas que alocam memória repetidamente, esses vazamentos podem consumir toda a memória disponível do sistema e causar problemas de desempenho ou falhas.

Lembre-se: cada malloc() deve ter um free() correspondente. Este emparelhamento é essencial para um gerenciamento de memória responsável na programação C.

challenge icon

Desafio

Fácil

Escreva um programa em C que demonstre o ciclo de vida completo da alocação e desalocação dinâmica de memória. Seu programa deve:

  1. Ler um número inteiro count do usuário, representando quantos inteiros serão armazenados
  2. Usar malloc() com sizeof() para alocar dinamicamente memória para um array de count inteiros
  3. Verificar se a alocação de memória foi bem-sucedida - se falhar, imprimir Memory allocation failed! e encerrar o programa
  4. Se a alocação for bem-sucedida, imprimir Memory allocated successfully!
  5. Ler count valores inteiros do usuário e armazená-los no array alocado
  6. Calcular e imprimir a soma de todos os valores no formato: Sum: [value]
  7. Encontrar e imprimir o valor máximo no formato: Maximum: [value]
  8. Usar free() para desalocar a memória
  9. Imprimir Memory freed successfully! para confirmar a limpeza

Lembre-se de incluir o cabeçalho <stdlib.h> para usar malloc() e free(). Este desafio demonstra o emparelhamento essencial de malloc() e free() para evitar vazamentos de memória em seus programas.

Por exemplo, se a entrada for:

4
15 8 23 12

Sua saída deve ser:

Memory allocated successfully!
Sum: 58
Maximum: 23
Memory freed successfully!

Este desafio reforça o conceito crítico de que cada bloco de memória alocado dinamicamente deve ser devidamente liberado quando não for mais necessário, completando o ciclo responsável de gerenciamento de memória na programação C.

Folha de consulta

Use free() para desalocar memória que foi alocada com malloc():

#include <stdlib.h>

int *ptr = (int*)malloc(sizeof(int));  // Alocar memória
*ptr = 42;  // Usar a memória
free(ptr);  // Liberar a memória quando terminar

Cada malloc() deve ter um free() correspondente para evitar vazamentos de memória. O ponteiro passado para free() deve ser o mesmo ponteiro retornado por malloc().

Experimente você mesmo

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

int main() {
    int count;
    
    // Leia o número de inteiros para armazenar
    scanf("%d", &count);
    
    // TODO: Escreva seu código abaixo
    // 1. Alocar memória usando malloc() com sizeof()
    // 2. Verificar se a alocação foi bem-sucedida
    // 3. Ler os valores inteiros e armazená-los
    // 4. Calcular a soma e encontrar o máximo
    // 5. Liberar a memória alocada
    
    return 0;
}
quiz iconTeste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Logic & Flow