Menu
CoddyTech

Alocando com calloc()

Parte da seção Lógica e Fluxo do Journey de C da Coddy. Lição 36 de 63.

Embora malloc() seja a função mais comum para alocação dinâmica de memória, C oferece outra alternativa útil: calloc(). A função calloc(), que significa "alocação contígua", oferece uma maneira conveniente de alocar memória para arrays com um importante benefício adicional.

Ao contrário de malloc(), que recebe um único argumento (total de bytes), calloc() recebe dois argumentos: o número de elementos que você quer alocar e o tamanho de cada elemento. Isso torna seu uso particularmente intuitivo ao trabalhar com arrays. Por exemplo:

#include <stdlib.h>

// Aloque espaço para 5 inteiros usando calloc()
int *arr = (int*)calloc(5, sizeof(int));

// Isso é equivalente a: malloc(5 * sizeof(int))

A principal vantagem de calloc() é que ela inicializa automaticamente toda a memória alocada com zero. Quando você usa malloc(), a memória alocada contém quaisquer valores aleatórios que estavam armazenados nela anteriormente, mas calloc() garante que cada byte seja definido como zero. Isso significa que todos os inteiros serão 0, todos os números de ponto flutuante serão 0.0 e todos os ponteiros serão NULL.

Assim como malloc(), calloc() retorna um ponteiro para a memória alocada ou NULL se a alocação falhar, então você deve sempre verificar se houve falha na alocação e se lembrar de liberar a memória com free() quando terminar de usá-la.

challenge icon

Desafio

Fácil

Escreva um programa em C que demonstre o uso de calloc() para alocação dinâmica de memória com inicialização automática em zero. Seu programa deve:

  1. Ler do usuário um inteiro size que representa o número de inteiros a serem alocados
  2. Usar calloc() para alocar dinamicamente memória para um array de size inteiros
  3. Verificar se a alocação de memória foi bem-sucedida — se falhar, imprimir Memory allocation failed! e encerrar o programa
  4. Se a alocação for bem-sucedida, imprimir Memory allocated and initialized to zero!
  5. Imprimir todos os valores iniciais do array para demonstrar que são zero, no formato: Initial values: [value1] [value2] [value3] ...
  6. Ler size valores inteiros do usuário e armazená-los no array alocado
  7. Imprimir todos os valores atualizados no formato: Updated values: [value1] [value2] [value3] ...
  8. Calcular e imprimir a soma de todos os valores no formato: Sum: [value]
  9. Usar free() para desalocar a memória
  10. Imprimir Memory freed! para confirmar a limpeza

Lembre-se de incluir o cabeçalho <stdlib.h> para usar calloc() e free(). Este desafio demonstra a principal vantagem de calloc() em relação a malloc(): a inicialização automática em zero de toda a memória alocada.

Por exemplo, se a entrada for:

3
10 20 30

Sua saída deve ser:

Memory allocated and initialized to zero!
Initial values: 0 0 0
Updated values: 10 20 30
Sum: 60
Memory freed!

Este desafio destaca como calloc() oferece um estado inicial limpo e previsível para seus arrays alocados dinamicamente, eliminando os valores imprevisíveis de lixo que malloc() pode deixar.

Experimente você mesmo

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

int main() {
    int size;
    
    // Leia o tamanho do array
    scanf("%d", &size);
    
    // TODO: Escreva seu código abaixo
    // Use calloc() para alocar memória para o array
    // Verifique se a alocação foi bem-sucedida
    // Imprima os valores iniciais (devem ser zero)
    // Leia e armazene os valores de entrada
    // Imprima os valores atualizados
    // Calcule e imprima a soma
    // Libere a memória alocada
    
    return 0;
}
quiz iconTeste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Lógica e Fluxo

Pratique por conta própria: Compilador de C online