malloc e free
Aloque no heap.
malloc e free é uma aula grátis de C Academy no CoddyKit. Esta é a aula 1 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.
A área de alocação dinâmica
Até agora, as variáveis viviam na pilha, com um tempo de vida fixo. A área de alocação dinâmica permite solicitar memória em tempo de execução e mantê-la pelo tempo necessário.
Você gerencia a memória dessa área por conta própria usando funções de <stdlib.h>.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(sizeof(int));
*p = 99;
printf("%d\n", *p);
free(p);
return 0;
}Chamando malloc
malloc(size) reserva size bytes e retorna um ponteiro para eles, ou NULL em caso de falha.
A memória fica não inicializada: seu conteúdo é indeterminado.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(sizeof(int));
*p = 7;
printf("value = %d\n", *p);
free(p);
return 0;
}Dimensionando com sizeof
Sempre dimensione as alocações com sizeof para que o código funcione corretamente em qualquer plataforma.
Escrever sizeof(*p) associa automaticamente o tamanho ao tipo do ponteiro.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
double *p = malloc(sizeof(*p));
*p = 3.14;
printf("%f\n", *p);
free(p);
return 0;
}Sempre verifique NULL
Se a alocação falhar, malloc retornará NULL. Desreferenciá-lo fará o programa falhar.
Verifique o resultado antes de usá-lo.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(sizeof(int));
if (p == NULL) {
printf("allocation failed\n");
return 1;
}
*p = 5;
printf("ok: %d\n", *p);
free(p);
return 0;
}Alocando uma matriz
Para armazenar muitos elementos, multiplique o tamanho do elemento pela quantidade.
malloc(n * sizeof(int)) cria espaço para n inteiros.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 5;
int *arr = malloc(n * sizeof(int));
for (int i = 0; i < n; i++) arr[i] = i * i;
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
printf("\n");
free(arr);
return 0;
}Matrizes na área dinâmica usam indexação por ponteiro
Uma matriz na área de alocação dinâmica é acessada por meio de seu ponteiro com a conhecida sintaxe arr[i], que é equivalente a *(arr + i).
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *arr = malloc(3 * sizeof(int));
arr[0] = 10;
*(arr + 1) = 20;
arr[2] = 30;
printf("%d %d %d\n", arr[0], arr[1], arr[2]);
free(arr);
return 0;
}Liberando memória
free(p) devolve o bloco ao alocador. Depois disso, você não deve usar p para acessar essa memória.
Todo malloc bem-sucedido precisa de um free correspondente.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
char *buf = malloc(16);
if (buf) {
buf[0] = 'A';
printf("%c\n", buf[0]);
free(buf);
}
return 0;
}free(NULL) é seguro
Chamar free com um ponteiro NULL não faz nada e é perfeitamente válido.
Isso simplifica o código de limpeza que pode ser executado antes que a alocação seja bem-sucedida.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = NULL;
free(p);
printf("free(NULL) was safe\n");
return 0;
}Retornando memória da área dinâmica
Ao contrário das variáveis da pilha, a memória da área de alocação dinâmica sobrevive depois que a função retorna. Isso permite que uma função aloque e devolva um bloco de memória.
#include <stdio.h>
#include <stdlib.h>
int *make_range(int n) {
int *a = malloc(n * sizeof(int));
for (int i = 0; i < n; i++) a[i] = i;
return a;
}
int main(void) {
int *r = make_range(4);
printf("%d %d\n", r[0], r[3]);
free(r);
return 0;
}Não converta malloc em C
Em C, malloc retorna um void *, que é convertido automaticamente para qualquer tipo de ponteiro.
Fazer a conversão é desnecessário e pode ocultar a ausência da inclusão de <stdlib.h>.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
long *p = malloc(sizeof(long));
*p = 1234567L;
printf("%ld\n", *p);
free(p);
return 0;
}Não libere duas vezes
Chamar free duas vezes para o mesmo ponteiro é comportamento indefinido e pode corromper a área de alocação dinâmica.
Defina o ponteiro como NULL depois de liberá-lo para tornar inofensivo um uso acidental.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = malloc(sizeof(int));
*p = 1;
free(p);
p = NULL;
free(p);
printf("no double free\n");
return 0;
}Verificação rápida
Teste seus conhecimentos sobre malloc e free.
Recapitulação
Você aprendeu os fundamentos da alocação dinâmica:
malloc(size)reserva bytes não inicializados e retornaNULLem caso de falha.- Sempre verifique o resultado e dimensione com
sizeof. free(p)devolve a memória; todo malloc precisa de um free.free(NULL)é seguro; liberar duas vezes resulta em comportamento indefinido.
Perguntas Frequentes
A aula “malloc e free” é grátis?
Sim — o texto completo de “malloc e free” é 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 “malloc e free”?
Aloque no heap. 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 1 de 4.
Quanto tempo leva a aula “malloc e free”?
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.