Neste artigo
- Como criar uma struct?
- Como acessar uma struct por um ponteiro?
- O que o malloc faz?
- Por que o free é obrigatório?
- Como juntar tudo: um nó de lista
- E em Go, que tem struct e ponteiro?
- Aí você pergunta: e em Python e PHP?
- Como o mesmo conceito aparece em cada linguagem?
- Aí você pergunta: o que isso tem a ver com desempenho?
- Quais são os erros mais comuns com malloc e free?
- Agora é com você!
Struct é um tipo criado pelo programador que agrupa várias variáveis, de tipos diferentes, debaixo de um nome só. Alocação dinâmica de memória é pedir um bloco de memória enquanto o programa está rodando e devolvê-lo quando não é mais necessário. Em C, quem pede é a função malloc, e quem devolve é a função free.
No artigo sobre tuplas, ficou uma promessa: em C não existe tupla, e quem agrupa valores de tipos diferentes é a struct. E no artigo sobre ponteiros, você aprendeu a guardar endereços. Hoje as duas peças se encontram. Com struct, malloc e free, você passa a criar dados novos durante a execução do programa, e é exatamente isso que uma lista encadeada faz a cada valor que recebe. As duas ideias não pertencem a uma linguagem só: o Go também tem struct, o Python e o PHP fazem o mesmo papel com classes, e as quatro pedem e devolvem memória. O que muda é quem devolve. Este artigo começa pelo C, onde nada fica escondido, passa pelas outras três linguagens e termina com o que isso tem a ver com desempenho.
Pense no vestiário de uma academia. Você chega, pede um armário, e a recepção entrega uma chave com o número dele. Você usa o tempo que precisar. Na saída, devolve a chave, e o armário fica livre para outra pessoa. Quem vai embora com a chave no bolso deixa um armário ocupado à toa. O malloc é o pedido, o endereço é a chave, e o free é a devolução.

Como criar uma struct?
Você descreve os campos uma vez e depois cria quantas variáveis quiser daquele tipo. O acesso a cada campo é com um ponto:
#include <stdio.h>
struct Aluno {
char nome[20];
int idade;
double nota;
};
int main(void)
{
struct Aluno aluno = {"Ana", 30, 7.5};
printf("%s\n", aluno.nome);
printf("%d\n", aluno.idade);
aluno.nota = 8.5;
printf("%.1f\n", aluno.nota);
return 0;
}
Saída:
Ana 30 8.5
O material do professor Paulo Feofiloff, do IME-USP, chama a struct de registro: um pacote de variáveis, em que cada variável é um campo. É a mesma ideia da ficha de cadastro, com um espaço para cada informação.
Como acessar uma struct por um ponteiro?
Com a seta. Quando o que você tem na mão é o endereço da struct, o ponto dá lugar a ->:
#include <stdio.h>
struct Aluno {
char nome[20];
int idade;
double nota;
};
int main(void)
{
struct Aluno aluno = {"Ana", 30, 7.5};
struct Aluno *ponteiro = &aluno;
(*ponteiro).nota = 8.0; // jeito longo
ponteiro->nota = 9.0; // jeito curto, com a seta
printf("%.1f\n", aluno.nota);
return 0;
}
Saída:
9.0
| Você tem | Como acessa o campo | Exemplo |
|---|---|---|
| A própria struct | Ponto | aluno.nota |
| O endereço da struct | Seta | ponteiro->nota |
As duas linhas do programa fazem a mesma coisa. A seta é só uma abreviação de (*ponteiro).nota, e os parênteses desse jeito longo são obrigatórios, por causa da ordem em que o C lê os operadores. Na prática, a seta é a forma que você vai encontrar.
O que o malloc faz?
Até aqui, toda variável tinha o tamanho decidido na hora de escrever o programa. Só que muitas vezes a quantidade de memória só fica conhecida com o programa rodando: quantos alunos o usuário vai cadastrar? É para isso que serve a alocação dinâmica.
O malloc recebe a quantidade de bytes desejada e devolve o endereço de um bloco desse tamanho. Para não fazer a conta dos bytes na mão, entra o sizeof, que informa quantos bytes um tipo ocupa:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int quantidade = 3;
int *numeros = malloc(quantidade * sizeof(int));
if (numeros == NULL) {
printf("faltou memoria\n");
return 1;
}
for (int i = 0; i < quantidade; i++) {
numeros[i] = (i + 1) * 10;
}
for (int i = 0; i < quantidade; i++) {
printf("%d\n", numeros[i]);
}
free(numeros);
numeros = NULL;
return 0;
}
Saída:
10 20 30

Na máquina usada para testar este exemplo, um int ocupa 4 bytes, então o pedido foi de 12 bytes. Em outra máquina o número pode ser diferente, e o sizeof cuida disso sozinho. Repare também que o bloco é usado com colchetes, como um vetor qualquer.
ATENÇÃO: a memória é finita. Quando não há bloco disponível, o malloc devolve NULL. Por isso o programa testa o resultado antes de usar, como recomenda o material do IME-USP sobre alocação dinâmica.
Por que o free é obrigatório?
Porque a memória pedida com malloc não é devolvida sozinha quando a função termina. Ela continua reservada até alguém chamar free.
Um programa que pede e nunca devolve vai ocupando cada vez mais memória. Isso tem nome: vazamento de memória. Em um programa que roda por dois segundos, ninguém percebe. Em um servidor que fica ligado por meses, é um problema sério.
Depois do free, o endereço guardado no ponteiro deixa de valer. Por isso o exemplo termina com numeros = NULL: o material do IME-USP sugere esse cuidado para o ponteiro não ficar “solto”, apontando para um bloco que já foi devolvido.
Para conferir se o seu programa devolveu tudo, existe uma ferramenta chamada Valgrind, indicada no mesmo material. Os dois programas deste artigo que usam malloc passaram por ela sem nenhum vazamento.
Como juntar tudo: um nó de lista
Agora as três peças no mesmo programa. Uma struct que guarda um valor e o endereço de outra struct do mesmo tipo é chamada de nó. Com dois nós ligados, já existe uma lista:
#include <stdio.h>
#include <stdlib.h>
struct No {
int valor;
struct No *proximo;
};
int main(void)
{
struct No *primeiro = malloc(sizeof(struct No));
struct No *segundo = malloc(sizeof(struct No));
if (primeiro == NULL || segundo == NULL) {
printf("faltou memoria\n");
return 1;
}
primeiro->valor = 10;
primeiro->proximo = segundo;
segundo->valor = 20;
segundo->proximo = NULL;
for (struct No *atual = primeiro; atual != NULL; atual = atual->proximo) {
printf("%d\n", atual->valor);
}
free(segundo);
free(primeiro);
return 0;
}
Saída:
10 20

Leia o for com calma: ele começa no primeiro nó, mostra o valor e pula para o endereço guardado em proximo. Quando encontra NULL, para. No fim, um free para cada malloc. Se você entendeu este programa, o artigo sobre lista encadeada vai parecer uma continuação natural.
E em Go, que tem struct e ponteiro?
O Go tem os dois, e a escrita é parecida com a do C. A diferença está na memória: você não chama free. A documentação do Go explica que cada variável existe enquanto houver alguma referência a ela. Quando ninguém mais aponta para o nó, a própria linguagem recolhe a memória.
package main
import "fmt"
type Aluno struct {
nome string
idade int
nota float64
}
type No struct {
valor int
proximo *No
}
func main() {
aluno := Aluno{"Ana", 30, 7.5}
ponteiro := &aluno
ponteiro.nota = 9.0 // o ponto serve também para o endereço
fmt.Printf("%s %d %.1f\n", aluno.nome, aluno.idade, aluno.nota)
segundo := &No{valor: 20} // o campo proximo começa em nil
primeiro := &No{valor: 10, proximo: segundo}
for atual := primeiro; atual != nil; atual = atual.proximo {
fmt.Println(atual.valor)
}
}
Saída:
Ana 30 9.0 10 20
Três detalhes. O &No{...} cria o nó e já devolve o endereço dele, sem malloc e sem sizeof. O campo proximo que não recebeu valor começou em nil, e foi nele que o for parou. E, no lugar da seta, o Go usou o ponto mesmo com o endereço na mão: ponteiro.nota e atual.proximo.
Aí você pergunta: e em Python e PHP?
Nessas linguagens, o papel da struct é feito pela classe, e você não chama malloc nem free. Veja em Python:
class Aluno:
def __init__(self, nome, idade, nota):
self.nome = nome
self.idade = idade
self.nota = nota
aluno = Aluno("Ana", 30, 7.5)
aluno.nota = 8.5
print(aluno.nome, aluno.nota)
Saída:
Ana 8.5
E em PHP:
<?php
class Aluno
{
public function __construct(
public string $nome,
public int $idade,
public float $nota,
) {
}
}
$aluno = new Aluno("Ana", 30, 7.5);
$aluno->nota = 8.5;
echo $aluno->nome, " ", $aluno->nota, "\n";
Saída:
Ana 8.5
Repare que o PHP usa a mesma seta do C para chegar ao campo. A memória continua sendo pedida e devolvida, só que quem faz isso é a própria linguagem. A documentação do Python explica que os objetos ficam em uma área de memória administrada pelo interpretador, sem controle direto de quem programa. Foque no conceito, e não na linguagem!
Como o mesmo conceito aparece em cada linguagem?
Nas quatro linguagens existem as duas ideias deste artigo: juntar dados em um tipo novo e pedir memória com o programa rodando. O que muda é o nome e, principalmente, quem devolve a memória.
| Linguagem | Quem agrupa os dados | Quem pede a memória | Quem devolve |
|---|---|---|---|
| C | struct | Você, com malloc | Você, com free |
| Go | struct | A linguagem, quando o valor é criado | A linguagem, com o coletor de lixo |
| Python | Classe | A linguagem, quando o objeto é criado | A linguagem |
| PHP | Classe | A linguagem, quando o objeto é criado | A linguagem |
No Go, quem recolhe é o coletor de lixo, a parte da linguagem que encontra a memória que ninguém mais usa. O manual do PHP descreve um mecanismo parecido: cada valor tem um contador de quantas variáveis o usam, e a memória pode ser liberada quando esse contador chega a zero.
Aí você pergunta: o que isso tem a ver com desempenho?
Muito! Pedir memória dá trabalho ao sistema, e devolver também. O programa abaixo mede esse trabalho. Ele guarda um milhão de nós, soma os valores e devolve a memória, de dois jeitos: com um malloc para cada nó, como na lista do exemplo anterior, e com um malloc só, do tamanho de todos os nós juntos.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
struct No {
int valor;
struct No *proximo;
};
int main(void)
{
int quantidade = 1000000;
long long soma = 0;
// primeiro jeito: um pedido de memória para cada nó
clock_t inicio = clock();
struct No *primeiro = NULL;
for (int i = 0; i < quantidade; i++) {
struct No *novo = malloc(sizeof(struct No));
if (novo == NULL) {
printf("faltou memoria\n");
return 1;
}
novo->valor = i;
novo->proximo = primeiro;
primeiro = novo;
}
while (primeiro != NULL) {
struct No *seguinte = primeiro->proximo;
soma = soma + primeiro->valor;
free(primeiro);
primeiro = seguinte;
}
double um_por_um = (double) (clock() - inicio) * 1000 / CLOCKS_PER_SEC;
// segundo jeito: um pedido só, com espaço para todos os nós
inicio = clock();
struct No *bloco = malloc(quantidade * sizeof(struct No));
if (bloco == NULL) {
printf("faltou memoria\n");
return 1;
}
for (int i = 0; i < quantidade; i++) {
bloco[i].valor = i;
bloco[i].proximo = NULL;
}
for (int i = 0; i < quantidade; i++) {
soma = soma + bloco[i].valor;
}
free(bloco);
bloco = NULL;
double de_uma_vez = (double) (clock() - inicio) * 1000 / CLOCKS_PER_SEC;
printf("tamanho de um nó: %zu bytes\n", sizeof(struct No));
printf("soma dos dois jeitos: %lld\n", soma);
printf("um milhão de pedidos: %.0f ms\n", um_por_um);
printf("um pedido só: %.0f ms\n", de_uma_vez);
return 0;
}
Saída (os tempos mudam a cada execução e de um computador para outro):
tamanho de um nó: 16 bytes soma dos dois jeitos: 999999000000 um milhão de pedidos: 33 ms um pedido só: 19 ms
Cada nó ocupa 16 bytes na máquina do teste. Com um pedido para cada nó, foram um milhão de chamadas ao malloc e um milhão ao free, e o trabalho levou 33 milissegundos. Com um pedido só, de 16 milhões de bytes, levou 19: o mesmo serviço em pouco mais da metade do tempo. O teste foi compilado com o GCC sem opções de otimização e passou pelo Valgrind sem nenhum vazamento.
Nas linguagens que devolvem a memória sozinhas, o trabalho não some: ele passa para a linguagem. A documentação do Go reconhece que a alocação e a coleta têm um custo e afirma que evitar a criação de lixo desnecessário pode fazer grande diferença. Ela também conta que o compilador guarda as variáveis na área da própria função sempre que consegue, e só usa a área do coletor quando precisa.
É por isso que o assunto volta em tantos lugares:
- Nas estruturas de dados: cada nó de uma lista encadeada é um bloco pedido durante a execução, como no programa dos dois nós.
- Nos programas que ficam ligados por muito tempo: memória pedida e não devolvida se acumula. É o vazamento de memória.
- Na otimização: menos pedidos de memória significam menos trabalho, para o sistema ou para o coletor.
ATENÇÃO: o pedido único só serve quando a quantidade é conhecida antes. A vantagem de pedir um nó de cada vez é poder crescer aos poucos, e é disso que a lista encadeada tira proveito.
Quais são os erros mais comuns com malloc e free?
- Esquecer o free. Cada
mallocprecisa do seufree, senão a memória vaza. - Usar o bloco depois do free. O endereço ainda está no ponteiro, mas o bloco não é mais seu.
- Não testar o NULL. Se o
mallocfalhar e o programa usar o ponteiro mesmo assim, ele quebra. - Pedir o tamanho errado. Escrever o número de bytes na mão é pedir para errar. Use
sizeof. - Chamar free duas vezes para o mesmo bloco. O material do IME-USP trata essa situação como má ideia: o bloco já foi devolvido na primeira vez.
Agora é com você!
Primeiro no papel. Desenhe a memória depois de cada linha do programa dos dois nós: onde está cada bloco e o que cada ponteiro guarda. Depois responda: o que aconteceria se a linha segundo->proximo = NULL fosse apagada?
Depois, no computador: crie uma struct Produto com nome e preço, peça memória para um produto com malloc, preencha os campos com a seta, mostre na tela e libere com free. Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!
Até o próximo artigo!
Confiança Sempre!!!
Fontes:
- Instituto de Matemática e Estatística da USP, material do professor Paulo Feofiloff. Registros e structs, com a definição de registro e de campo e as duas formas de acesso por ponteiro.
- Instituto de Matemática e Estatística da USP, material do professor Paulo Feofiloff. Alocação dinâmica de memória, com as funções malloc e free, o operador sizeof, o teste do NULL e a indicação do Valgrind.
- Python Software Foundation, documentação oficial. Memory Management, com a descrição da área de memória administrada pelo interpretador.
- IME-USP. MAC0122, aula 7: alocação dinâmica de memória, com o malloc como pedido de um bloco de bytes consecutivos que devolve o endereço do bloco.
- UFPE, Centro de Informática. Introdução à Programação: ponteiros, vetores e alocação dinâmica, com o malloc, o retorno NULL quando falta memória e o free.
- UTFPR. Computação 2, aula 9: alocação dinâmica, com a região de memória livre de onde o malloc tira os blocos.
- UFSC, Curso de Programação C em Ambientes Linux. Aula 5: alocação dinâmica de memória, com o malloc, o free e o operador sizeof.
- Unicamp, Instituto de Computação. MC102, alocação dinâmica de memória, com o cálculo do tamanho pelo sizeof e um exemplo com struct.
- UFSCar. AED1, aula 8: alocação dinâmica de memória, com os casos em que a quantidade de memória só é conhecida durante a execução.
- Go, documentação oficial. Frequently Asked Questions (em inglês), com a explicação de que cada variável existe enquanto houver referências a ela e de que a memória é recolhida pela própria linguagem, o custo da alocação e da coleta e o lugar em que o compilador guarda as variáveis.
- PHP, manual oficial. Garbage Collection: Collecting Cycles (em inglês), com a contagem de referências e a liberação do valor quando o contador chega a zero.
- Go, documentação oficial. The Go Programming Language Specification (em inglês), com o tipo ponteiro, o valor nil do ponteiro não inicializado e o endereço de um valor composto criado com &.
- Os exemplos deste artigo foram executados em Python 3.13, PHP 8.3, GCC 13 e Go 1.24, e os programas com malloc foram conferidos com o Valgrind.

Continue a conversa