C Academy · Aula

Aumentando com realloc

Redimensione um vetor dinâmico.

Aumentando com realloc é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 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.

Quando um malloc não é suficiente

Às vezes, você aloca uma matriz, preenche-a e depois descobre que precisa de mais espaço. Não é possível simplesmente escrever além do fim.

realloc permite redimensionar um bloco existente do heap, preservando os dados que já estavam nele.

A assinatura de realloc

realloc(ptr, new_bytes) recebe o ponteiro antigo e o novo tamanho total em bytes.

Ela retorna um ponteiro para um bloco do novo tamanho. A primeira parte dos dados é preservada até o menor entre os tamanhos antigo e novo.

int *bigger = realloc(a, new_n * sizeof(*a));

O bloco pode ser movido

realloc pode aumentar o bloco no próprio local ou alocar um novo bloco, copiar seus dados e liberar o antigo.

De qualquer forma, o ponteiro antigo pode se tornar inválido. A partir desse momento, você deve usar o ponteiro retornado.

a = realloc(a, new_n * sizeof(*a));
/* the old value of a may no longer be valid */

A armadilha da atribuição a si mesmo

Escrever a = realloc(a, ...) parece organizado, mas é perigoso: se realloc retornar NULL, você terá sobrescrito a e perdido o ponteiro original, vazando o bloco antigo.

Use uma variável temporária.

int *tmp = realloc(a, new_n * sizeof(*a));
if (tmp == NULL) { /* a is still valid */ return 1; }
a = tmp;

Aumentando uma matriz com segurança

Este programa aloca 3 int e depois aumenta o espaço para 6 com realloc, preservando os três primeiros valores.

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

int main(void) {
    int *a = malloc(3 * sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < 3; i++) a[i] = i + 1;

    int *tmp = realloc(a, 6 * sizeof(*a));
    if (!tmp) { free(a); return 1; }
    a = tmp;

    for (int i = 3; i < 6; i++) a[i] = i + 1;
    for (int i = 0; i < 6; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

Os novos bytes não são inicializados

Ao aumentar um bloco, o espaço extra no final contém lixo, assim como a memória recém-obtida com malloc.

realloc preserva os dados antigos, mas não zera a nova região. Inicialize-a antes de ler.

a = realloc(a, 6 * sizeof(*a));
for (int i = 3; i < 6; i++) a[i] = 0;  /* clear new slots */

A estratégia de duplicação

Chamar realloc para cada elemento é lento. Um truque clássico é duplicar a capacidade sempre que o espaço acabar.

Isso mantém pequeno o número de realocações à medida que a matriz cresce, oferecendo bom desempenho médio.

if (count == cap) {
    cap = cap ? cap * 2 : 4;
    int *tmp = realloc(a, cap * sizeof(*a));
    if (!tmp) { free(a); return 1; }
    a = tmp;
}

Construindo uma matriz por acréscimo

Este programa começa vazio e acrescenta números, duplicando a capacidade conforme necessário.

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

int main(void) {
    int *a = NULL;
    size_t count = 0, cap = 0;
    for (int v = 1; v <= 5; v++) {
        if (count == cap) {
            cap = cap ? cap * 2 : 2;
            int *tmp = realloc(a, cap * sizeof(*a));
            if (!tmp) { free(a); return 1; }
            a = tmp;
        }
        a[count++] = v;
    }
    for (size_t i = 0; i < count; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

realloc(NULL, n) funciona como malloc

Se você passar NULL como ponteiro, realloc se comportará exatamente como malloc.

Por isso, começar com a = NULL funciona no laço de duplicação: o primeiro realloc aloca o bloco inicial.

int *a = NULL;
a = realloc(a, 4 * sizeof(*a));  /* same as malloc(4 * sizeof(*a)) */

Reduzindo um bloco

realloc também pode tornar um bloco menor. Os dados até o novo tamanho são mantidos; o restante é descartado.

Reduzir pode devolver memória ao sistema, embora as implementações possam manter o bloco maior.

int *tmp = realloc(a, 2 * sizeof(*a));  /* down from more */
if (tmp) a = tmp;

Evite overflow na matemática

Quando a capacidade cresce muito, cap * sizeof(*a) pode causar overflow em um size_t e resultar em um número minúsculo.

Para arrays enormes, proteja a multiplicação ou use reallocarray nos sistemas que o disponibilizam.

if (cap > SIZE_MAX / sizeof(*a)) { /* overflow */ return 1; }
int *tmp = realloc(a, cap * sizeof(*a));

Verificação rápida

Teste sua compreensão de realloc.

Recapitulação

realloc redimensiona um bloco da heap e pode movê-lo; portanto, use sempre o ponteiro retornado.

Atribua o resultado a uma variável temporária para que uma falha não cause vazamento do bloco original. Aumente a capacidade dobrando-a para obter mais velocidade, inicialize os novos espaços e lembre-se de que realloc(NULL, n) equivale a malloc. A seguir, o senhor encapsulará essa lógica em um tipo de vetor reutilizável.

Perguntas Frequentes

A aula “Aumentando com realloc” é grátis?

Sim — o texto completo de “Aumentando com realloc” é 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 “Aumentando com realloc”?

Redimensione um vetor dinâmico. 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 2 de 4.

Quanto tempo leva a aula “Aumentando com realloc”?

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.

Todas as aulas deste curso

← Voltar para C Academy