malloc vs calloc: Diferenças-Chave Explicadas com Exemplos Práticos

O que é Alocação Dinâmica de Memória?

A alocação dinâmica de memória permite que um programa solicite e libere memória em tempo de execução. Em C, a biblioteca padrão fornece quatro funções principais para esse propósito – malloc(), calloc(), realloc() e free() – todas declaradas em stdlib.h.

malloc(): Alocar um Único Bloco de Memória

malloc() (abreviação de "memory allocation") reserva um bloco contíguo de bytes e retorna um ponteiro para o primeiro byte. O conteúdo do bloco recém-alocado é indeterminado, ou seja, contém quaisquer bits que aconteciam de estar naquela localização na memória.

Uso típico:

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

Se a solicitação falhar, malloc() retorna NULL.

calloc(): Alocar Múltiplos Blocos Inicializados com Zero

calloc() (abreviação de "contiguous allocation") recebe dois argumentos: o número de elementos e o tamanho de cada elemento. Ele aloca memória para todos os elementos e define automaticamente cada byte como zero, tornando-o ideal para arrays ou estruturas que precisam de um estado inicial limpo.

Uso típico:

int *p = (int *)calloc(n, sizeof(int));

Como malloc(), retorna NULL se a alocação falhar.

Quando Usar Cada Função

• malloc() – Use quando você precisa de um único bloco e planeja inicializar a memória manualmente. É ligeiramente mais rápido porque pula a etapa de zerar.
• calloc() – Use quando você precisa de um array ou estrutura que deve começar com todos os zeros. A inicialização automática protege contra uso acidental de valores lixo.

Visão Geral da Sintaxe

malloc()

void *malloc(size_t size);

calloc()

void *calloc(size_t num, size_t size);

Exemplos Práticos de Código

Exemplo 1: Usando malloc() para Armazenar 15 Inteiros

#include <stdlib.h>
#include <stdio.h>
int main(void) {
    int *ptr = malloc(15 * sizeof(*ptr));
    if (!ptr) {
        perror("malloc falhou");
        return EXIT_FAILURE;
    }
    ptr[5] = 480; // 6º elemento (índice base 0)
    printf("Valor do 6º inteiro é %d\n", ptr[5]);
    free(ptr);
    return EXIT_SUCCESS;
}

Saída: Valor do 6º inteiro é 480

Exemplo 2: Usando calloc() para Calcular uma Soma

#include <stdlib.h>
#include <stdio.h>
int main(void) {
    int *ptr = calloc(10, sizeof(int));
    if (!ptr) {
        perror("calloc falhou");
        return EXIT_FAILURE;
    }
    int sum = 0;
    for (int i = 0; i < 10; ++i) {
        ptr[i] = i; // inicialização redundante, mas mostrada para clareza
        sum += ptr[i];
    }
    printf("Soma = %d\n", sum);
    free(ptr);
    return EXIT_SUCCESS;
}

Saída: Soma = 45

Comparação Lado a Lado

Característica	malloc()	calloc()
Número de parâmetros	1 (tamanho)	2 (quantidade, tamanho)
Estado da memória após alocação	Não inicializada (lixo)	Inicializada com zero
Caso de uso típico	Bloco único, inicialização manual	Arrays ou estruturas precisando de início limpo
Desempenho	Mais rápido (sem zerar)	Mais lento (overhead de zerar)
Segurança	Maior risco de usar valores lixo	Menor risco devido à zeragem automática
Valor de retorno em falha	NULL	NULL
Header padrão	stdlib.h	stdlib.h

Conclusão

• Use malloc() quando precisar de um único bloco e o inicializará manualmente para um pequeno ganho de desempenho.
• Use calloc() quando precisar de memória inicializada com zero, especialmente para arrays ou structs, para evitar bugs sutis.
• Ambas as funções retornam NULL em falha; sempre verifique antes de desreferenciar.
• Lembre-se de liberar a memória alocada com free() para evitar vazamentos.