Algoritmos

Alocação de memória: o que acontece quando ninguém devolve

Capa do artigo Alocação de memória: o que acontece quando ninguém devolve
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. Como criar uma struct?
  2. Como acessar uma struct por um ponteiro?
  3. O que o malloc faz?
  4. Por que o free é obrigatório?
  5. Como juntar tudo: um nó de lista
  6. E em Go, que tem struct e ponteiro?
  7. Aí você pergunta: e em Python e PHP?
  8. Como o mesmo conceito aparece em cada linguagem?
  9. Aí você pergunta: o que isso tem a ver com desempenho?
  10. Quais são os erros mais comuns com malloc e free?
  11. 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.

História em quadrinhos em três quadros: no vestiário, uma pessoa pede um armário e recebe a chave do número 3, usa o armário e, na saída, devolve a chave na recepção
O malloc é o pedido do armário, 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ê temComo acessa o campoExemplo
A própria structPontoaluno.nota
O endereço da structSetaponteiro->nota
Ponto ou seta: depende do que você tem na mão.

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
Diagrama em três passos: o malloc entrega um bloco de três inteiros, o programa preenche com 10, 20 e 30, e o free devolve o bloco
O ciclo completo: pedir o bloco, usar e devolver.

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
Diagrama de dois nós de lista: o primeiro guarda 10 e o endereço do segundo, e o segundo guarda 20 e NULL
Dois nós ligados: cada um guarda um valor e o endereço do próximo.

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.

LinguagemQuem agrupa os dadosQuem pede a memóriaQuem devolve
CstructVocê, com mallocVocê, com free
GostructA linguagem, quando o valor é criadoA linguagem, com o coletor de lixo
PythonClasseA linguagem, quando o objeto é criadoA linguagem
PHPClasseA linguagem, quando o objeto é criadoA linguagem
As mesmas duas ideias em quatro linguagens.

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 malloc precisa do seu free, 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 malloc falhar 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:

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager. Como esse contêiner também carrega tags de publicidade, as estatísticas só são ativadas junto com Publicidade e marketing.

Exibem anúncios do Google AdSense e medem campanhas e e-mails: pixels da Meta e do TikTok e o Mautic.

Permite que o Google escolha anúncios com base nos seus interesses. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade e marketing.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.