C Academy · Aula

calloc e realloc

Memória zerada e redimensionada.

calloc e 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.

Além de malloc

Além de malloc, a biblioteca padrão oferece calloc para memória zerada e realloc para redimensionar um bloco existente.

Ambos estão em <stdlib.h>.

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

int main(void) {
    int *p = calloc(3, sizeof(int));
    printf("%d %d %d\n", p[0], p[1], p[2]);
    free(p);
    return 0;
}

calloc zera a memória

calloc(count, size) aloca espaço para count elementos de size bytes e define cada byte como zero.

Isso é conveniente quando você precisa começar com uma área limpa.

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

int main(void) {
    int *a = calloc(5, sizeof(int));
    int sum = 0;
    for (int i = 0; i < 5; i++) sum += a[i];
    printf("sum of zeroed array = %d\n", sum);
    free(a);
    return 0;
}

calloc tem dois argumentos

Ao contrário de malloc, calloc recebe separadamente a quantidade e o tamanho do elemento.

Ele também evita estouro ao multiplicar a quantidade pelo tamanho.

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

int main(void) {
    double *d = calloc(4, sizeof(double));
    d[2] = 1.5;
    printf("%f %f\n", d[0], d[2]);
    free(d);
    return 0;
}

malloc versus calloc

Use malloc quando você for sobrescrever todos os bytes de qualquer forma, e calloc quando depender de a memória começar zerada.

calloc custa um pouco mais por causa da operação de zeramento.

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

int main(void) {
    int *m = malloc(2 * sizeof(int));
    int *c = calloc(2, sizeof(int));
    m[0] = 5; m[1] = 6;
    printf("malloc: %d %d\n", m[0], m[1]);
    printf("calloc: %d %d\n", c[0], c[1]);
    free(m); free(c);
    return 0;
}

Aumentando com realloc

realloc(ptr, newsize) altera o tamanho de um bloco, preservando seu conteúdo existente até o menor dos tamanhos antigo e novo.

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

int main(void) {
    int *a = malloc(2 * sizeof(int));
    a[0] = 1; a[1] = 2;
    a = realloc(a, 4 * sizeof(int));
    a[2] = 3; a[3] = 4;
    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");
    free(a);
    return 0;
}

realloc pode mover o bloco

realloc pode retornar um endereço diferente se relocar o bloco para encontrar espaço.

Sempre atribua o resultado novamente e nunca continue usando o ponteiro antigo.

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 42;
    int *bigger = realloc(a, 100 * sizeof(int));
    printf("first element still %d\n", bigger[0]);
    free(bigger);
    return 0;
}

Padrão seguro para realloc

Se realloc falhar, ele retornará NULL, mas manterá o bloco original intacto.

Atribua o resultado primeiro a uma variável temporária para não perder o ponteiro antigo em caso de falha.

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

int main(void) {
    int *a = malloc(2 * sizeof(int));
    int *tmp = realloc(a, 8 * sizeof(int));
    if (tmp == NULL) {
        free(a);
        return 1;
    }
    a = tmp;
    a[7] = 99;
    printf("%d\n", a[7]);
    free(a);
    return 0;
}

Reduzindo um bloco

realloc também pode tornar um bloco menor. Os elementos iniciais são preservados; o restante é liberado.

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

int main(void) {
    int *a = malloc(6 * sizeof(int));
    for (int i = 0; i < 6; i++) a[i] = i;
    a = realloc(a, 3 * sizeof(int));
    printf("%d %d %d\n", a[0], a[1], a[2]);
    free(a);
    return 0;
}

Um bloco de memória crescente

Um padrão comum dobra a capacidade quando uma matriz fica cheia, amortizando o custo do crescimento.

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

int main(void) {
    int cap = 2, len = 0;
    int *a = malloc(cap * sizeof(int));
    for (int v = 0; v < 5; v++) {
        if (len == cap) {
            cap *= 2;
            a = realloc(a, cap * sizeof(int));
        }
        a[len++] = v;
    }
    printf("len=%d cap=%d last=%d\n", len, cap, a[len-1]);
    free(a);
    return 0;
}

realloc com NULL

realloc(NULL, size) se comporta exatamente como malloc(size).

Isso permite que uma rotina de crescimento trate a primeira alocação da mesma forma que as seguintes.

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

int main(void) {
    int *a = realloc(NULL, 3 * sizeof(int));
    a[0] = 7;
    printf("%d\n", a[0]);
    free(a);
    return 0;
}

Combinando-os

Você pode começar com calloc para obter um bloco de memória zerado e depois aumentá-lo com realloc. Os novos bytes adicionados ao aumentar o bloco não são zerados.

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

int main(void) {
    int *a = calloc(2, sizeof(int));
    a = realloc(a, 4 * sizeof(int));
    a[2] = 0; a[3] = 0;
    printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
    free(a);
    return 0;
}

Verificação rápida

Teste seus conhecimentos sobre calloc e realloc.

Recapitulação

Você aprendeu mais duas ferramentas de alocação:

calloc(count, size) aloca memória zerada e evita estouro na multiplicação.
realloc(ptr, newsize) redimensiona um bloco, possivelmente movendo-o.
Sempre atribua o resultado de realloc a uma variável temporária para evitar vazamentos em caso de falha.
realloc(NULL, size) funciona como malloc.

Perguntas Frequentes

A aula “calloc e realloc” é grátis?

Sim — o texto completo de “calloc e 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 “calloc e realloc”?

Memória zerada e redimensionada. 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 “calloc e 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