Até agora, todas as variáveis e vetores utilizados possuíam tamanho fixo, definido em tempo de compilação. Essa abordagem, embora simples, é limitada: muitas vezes não sabemos, antes da execução do programa, quantos elementos serão realmente necessários.

Nesta aula estudaremos a alocação dinâmica de memória, que permite reservar e liberar espaço na memória durante a execução do programa, de acordo com a necessidade real dos dados. Esse conceito é essencial para o restante da disciplina, pois praticamente todas as estruturas de dados dinâmicas (listas encadeadas, pilhas, filas, árvores, grafos) dependem dele. Veremos também um conjunto de recursos complementares da linguagem C — ponteiro para ponteiro, argumentos de linha de comando, const, bool e assert — que serão úteis ao longo de toda a disciplina.

Memória estática versus memória dinâmica

De forma simplificada, um programa em execução utiliza duas regiões principais de memória para armazenar dados: a pilha (stack) e o heap.

Todas as variáveis e vetores vistos até agora (como int idade; ou int vetor[10];) são alocados na pilha. A partir de agora, aprenderemos a alocar memória diretamente no heap, através de ponteiros.

Alocação dinâmica: a função malloc()

A função malloc() (memory allocation), definida na biblioteca <stdlib.h>, reserva um bloco de memória no heap com o tamanho (em bytes) especificado, e retorna um ponteiro para o início desse bloco.

tipo *ponteiro = (tipo *) malloc(quantidade * sizeof(tipo));

O operador sizeof é utilizado para calcular corretamente o número de bytes necessários para armazenar um valor do tipo desejado. Considere o exemplo abaixo, que aloca dinamicamente um vetor de n inteiros:

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

int main() {
    int n = 5;
    int *vetor;

    vetor = (int *) malloc(n * sizeof(int));

    if (vetor == NULL) {
        printf("Erro: memória insuficiente.\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        vetor[i] = i * 10;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", vetor[i]);
    }
    printf("\n");

    free(vetor);
    return 0;
}

Observe que, uma vez alocado, o vetor dinâmico vetor pode ser acessado exatamente como um vetor comum, utilizando colchetes (vetor[i]), pois um vetor nada mais é do que um ponteiro para o início de uma sequência de posições de memória contíguas.

Nem sempre há memória disponível suficiente para atender a uma solicitação. Quando isso ocorre, malloc() retorna NULL em vez de um endereço válido — por isso o exemplo acima já verifica if (vetor == NULL) logo após a alocação.

A função free()

Toda memória alocada dinamicamente com malloc() deve ser explicitamente liberada pelo programador quando não for mais necessária, através da função free(). Diferentemente das variáveis da pilha, a memória do heap não é liberada automaticamente quando a função termina.

free(ponteiro);

Caso a memória alocada nunca seja liberada, o programa passa a consumir memória desnecessariamente enquanto estiver em execução, um problema conhecido como vazamento de memória (memory leak). Em programas que executam por muito tempo, ou que alocam memória repetidamente, esse problema pode esgotar toda a memória disponível no sistema.

Exemplo: vetores dinâmicos de structs

A alocação dinâmica é especialmente útil quando combinada com structs, permitindo criar vetores de registros cujo tamanho só é conhecido durante a execução do programa.

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

typedef struct {
    char nome[50];
    float media;
} Aluno;

int main() {
    int n;
    printf("Quantos alunos? ");
    scanf("%d", &n);

    Aluno *turma = (Aluno *) malloc(n * sizeof(Aluno));
    if (turma == NULL) {
        return 1;
    }

    // Acesso idêntico ao de um vetor comum de structs
    for (int i = 0; i < n; i++) {
        turma[i].media = 0.0;
    }

    free(turma);
    return 0;
}

Note que turma é um ponteiro para Aluno, mas pode ser utilizado com a mesma notação de vetor (turma[i]) e com o operador ponto (turma[i].media), já que turma[i] acessa diretamente o registro, e não um ponteiro para ele.

Ponteiro para ponteiro

Um ponteiro para ponteiro é uma variável que armazena o endereço de outro ponteiro. Ele é declarado utilizando dois asteriscos (**) e é útil, por exemplo, quando uma função precisa alterar, por referência, o próprio ponteiro passado pela função chamadora (e não apenas o valor para o qual ele aponta).

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

// Aloca um vetor de n inteiros e devolve o ponteiro através de 'vetor'
void alocarVetor(int **vetor, int n) {
    *vetor = (int *) malloc(n * sizeof(int));
}

int main() {
    int *p = NULL;

    alocarVetor(&p, 5); // Passamos o endereço do ponteiro p

    if (p != NULL) {
        p[0] = 42;
        printf("%d\n", p[0]);
        free(p);
    }

    return 0;
}

Sem o segundo nível de indireção (int **vetor), a função alocarVetor receberia apenas uma cópia do ponteiro p, e a alocação feita dentro dela seria perdida ao final da função, exatamente pelo mesmo motivo pelo qual a passagem por valor não altera variáveis simples.

Argumentos de linha de comando (argc e argv)

Até agora, sempre lemos dados através de scanf(), com o programa já em execução. Também é possível passar informações para um programa no momento em que ele é iniciado, através de argumentos de linha de comando. Para isso, a função main() pode receber dois parâmetros:

int main(int argc, char *argv[]) {
    // ...
}

#include <stdio.h>

int main(int argc, char *argv[]) {
    int i;

    printf("Numero de argumentos: %d\n", argc);

    for (i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }

    return 0;
}

Compilando e executando esse programa com dois argumentos:

gcc -Wall main.c -o programa
./programa turma.txt 10

produz a saída:

Numero de argumentos: 3
argv[0] = ./programa
argv[1] = turma.txt
argv[2] = 10

Liberdades de estilo a partir de agora

A programação estruturada surgiu para combater o "código espaguete" — programas com fluxo tão emaranhado (cheio de saltos e desvios) que se tornavam quase impossíveis de entender ou corrigir. Algumas regras eram muito rígidas porque ajudavam programadores iniciantes a internalizar essa disciplina, evitando exatamente esse tipo de bagunça.

Hoje, a maioria delas virou uma recomendação de legibilidade, não uma proibição absoluta: usamos break, múltiplos return e declarações locais quando tornam o código mais claro, mas continuamos evitando construções que dificultam entender o fluxo do programa (como goto, por exemplo).

Múltiplos pontos de retorno. Uma função pode ter mais de um return, encerrando assim que o resultado é conhecido:

int ehPositivo(int n) {
    if (n > 0) return 1;
    return 0;
}

break em laços. Um for ou while pode ser interrompido antes de terminar, assim que a busca não precisar mais continuar:

for (i = 0; i < n; i++) {
    if (vetor[i] == alvo) break;
}

Variáveis declaradas perto do uso. Uma variável pode ser declarada no meio da função, próxima de onde é usada pela primeira vez, em vez de todas juntas no topo:

printf("Processando...\n");
int soma = 0; // declarada só aqui, quando passa a ser necessária

Isso vale inclusive para a variável de controle do for, declarada diretamente dentro do próprio laço:

for (int i = 0; i < n; i++) {
    printf("%d ", vetor[i]);
}

O qualificador const

Quando uma função recebe um ponteiro apenas para ler os dados apontados, sem nunca modificá-los, é uma boa prática declarar o parâmetro com o qualificador const. Isso comunica a intenção da função (tanto para quem a lê quanto para o compilador) e faz com que o próprio compilador acuse um erro caso o corpo da função tente, por engano, alterar esse dado.

void imprimirAluno(const Aluno *aluno) {
    printf("%s: %.2f\n", aluno->nome, aluno->media);

    aluno->media = 10.0; // erro de compilação: não é permitido alterar *aluno
}

Repare que imprimirAluno recebe um ponteiro (evitando a cópia de toda a struct), mas o const garante, em tempo de compilação, que essa função apenas lê o aluno apontado, sem risco de alterá-lo por engano — o melhor dos dois mundos: o desempenho de passar por ponteiro, com a segurança de passar por valor.

É por isso que funções como strlen e strcmp, da biblioteca padrão, recebem seus parâmetros como const char *: elas prometem apenas ler a string recebida, nunca modificá-la.

O tipo bool em C

Historicamente, C não possuía um tipo booleano nativo — condições eram sempre representadas por int (0 para falso, qualquer valor diferente de 0 para verdadeiro). Desde o padrão C99, porém, o cabeçalho <stdbool.h> disponibiliza o tipo bool e as constantes true/false, deixando o código mais legível:

#include <stdio.h>
#include <stdbool.h>

bool ehPar(int n) {
    return n % 2 == 0;
}

int main() {
    bool vetorVazio = true;

    if (ehPar(4)) {
        printf("4 e par\n");
    }

    printf("vetorVazio = %d\n", vetorVazio); // imprime 1

    return 0;
}

assert: verificando erros do programador

A macro assert, definida em <assert.h>, verifica se uma condição é verdadeira e, caso não seja, encerra o programa imediatamente com uma mensagem de erro indicando o arquivo e a linha da falha.

#include <assert.h>

float calcularMedia(float notas[], int n) {
    assert(n > 0); // nunca deveria ser chamada com n <= 0

    float soma = 0;
    for (int i = 0; i < n; i++) {
        soma += notas[i];
    }
    return soma / n;
}

Isso é bem diferente de um if comum, que continua sendo a ferramenta certa para tratar entradas inválidas vindas do usuário do programa — uma situação perfeitamente esperada, que o programa deve saber lidar sem simplesmente encerrar de forma abrupta:

int n;
printf("Quantas notas? ");
scanf("%d", &n);

if (n <= 0) { // erro do usuário: entrada inválida, situação esperada
    printf("Erro: a quantidade de notas deve ser positiva.\n");
    return 1;
}

Resumo: alocação estática versus dinâmica

Exercícios

1. Explique a diferença entre alocação estática e alocação dinâmica, indicando em qual região de memória cada uma ocorre e quando o tamanho de cada uma é definido.
2. Por que é necessário verificar se o retorno de malloc() é NULL antes de utilizar o ponteiro alocado? O que acontece se essa verificação for esquecida e a alocação falhar?
3. O que é um dangling pointer? Por que atribuir NULL a um ponteiro logo após chamar free() sobre ele é uma boa prática?
4. Escreva uma função void alocarInteiro(int **p, int valor) que aloque dinamicamente um único int, atribua valor a ele, e devolva o ponteiro alocado através do parâmetro p. Escreva também um main() que a utilize corretamente (incluindo a liberação da memória).
5. O que representam argc e argv na função main(int argc, char *argv[])? Se um programa for executado com ./programa a b c, qual é o valor de argc, e o que contém argv[0]?
6. Considere a função void imprimirAluno(const Aluno *aluno). O que o qualificador const impede que essa função faça? O que aconteceria se, dentro dela, tentássemos executar aluno->media = 10.0;?
7. Qual é a diferença entre const Aluno *aluno e Aluno * const aluno?
8. Explique, com um exemplo próprio (diferente dos vistos em aula), uma situação em que faria sentido usar assert, e outra em que faria sentido usar if. Justifique por que cada uma se encaixa no papel de "erro do programador" ou "erro do usuário".
9. Reescreva a função abaixo utilizando o tipo bool (de <stdbool.h>) como tipo de retorno, no lugar de int:

   int estaCheia(int ocupados, int capacidade) {
       return ocupados == capacidade;
   }
   

Sugestões de Respostas dos Exercícios

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

void alocarInteiro(int **p, int valor) {
    *p = (int *) malloc(sizeof(int));
    if (*p != NULL) {
        **p = valor;
    }
}

int main() {
    int *x = NULL;

    alocarInteiro(&x, 7);

    if (x != NULL) {
        printf("%d\n", *x);
        free(x);
    }

    return 0;
}

#include <stdbool.h>

bool estaCheia(int ocupados, int capacidade) {
    return ocupados == capacidade;
}