Allocare con calloc()

Fa parte della sezione Logica e flusso del percorso C di Coddy. Lezione 36 di 63.

Sebbene malloc() sia la funzione più comune per l'allocazione dinamica della memoria, C offre un'altra utile alternativa: calloc(). La funzione calloc(), che sta per "allocazione contigua", offre un modo pratico per allocare memoria per gli array con un importante vantaggio aggiuntivo.

A differenza di malloc(), che accetta un solo argomento (il numero totale di byte), calloc() accetta due argomenti: il numero di elementi che vuoi allocare e la dimensione di ciascun elemento. Questo lo rende particolarmente intuitivo quando lavori con gli array. Per esempio:

#include <stdlib.h>

// Alloca spazio per 5 numeri interi usando calloc()
int *arr = (int*)calloc(5, sizeof(int));

// Questo è equivalente a: malloc(5 * sizeof(int))

Il vantaggio principale di calloc() è che inizializza automaticamente a zero tutta la memoria allocata. Quando usi malloc(), la memoria allocata contiene qualunque valore casuale vi fosse memorizzato in precedenza, mentre calloc() garantisce che ogni byte sia impostato a zero. Questo significa che tutti gli interi saranno 0, tutti i numeri in virgola mobile saranno 0.0 e tutti i puntatori saranno NULL.

Come malloc(), calloc() restituisce un puntatore alla memoria allocata oppure NULL se l'allocazione non riesce, quindi dovresti sempre controllare che l'allocazione non sia fallita e ricordarti di free() la memoria quando hai finito di usarla.

Sfida

Facile

Scrivi un programma C che dimostri l'uso di calloc() per l'allocazione dinamica della memoria con inizializzazione automatica a zero. Il tuo programma dovrebbe:

Leggere dall'utente un intero size che rappresenta il numero di interi da allocare
Usare calloc() per allocare dinamicamente la memoria per un array di size interi
Verificare che l'allocazione della memoria sia riuscita: se non riesce, stampare Memory allocation failed! e terminare il programma
Se l'allocazione riesce, stampare Memory allocated and initialized to zero!
Stampare tutti i valori iniziali dell'array per dimostrare che sono zero, nel formato: Initial values: [value1] [value2] [value3] ...
Leggere dall'utente size valori interi e memorizzarli nell'array allocato
Stampare tutti i valori aggiornati nel formato: Updated values: [value1] [value2] [value3] ...
Calcolare e stampare la somma di tutti i valori nel formato: Sum: [value]
Usare free() per deallocare la memoria
Stampare Memory freed! per confermare la pulizia

Ricorda di includere l'header <stdlib.h> per usare calloc() e free(). Questa sfida dimostra il vantaggio principale di calloc() rispetto a malloc(): l'inizializzazione automatica a zero di tutta la memoria allocata.

Per esempio, se l'input è:

3
10 20 30

Il tuo output dovrebbe essere:

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

Questa sfida evidenzia come calloc() fornisca uno stato iniziale pulito e prevedibile per gli array allocati dinamicamente, eliminando i valori spazzatura imprevedibili che malloc() potrebbe lasciare.

Provalo tu

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

int main() {
    int size;
    
    // Leggi la dimensione dell'array
    scanf("%d", &size);
    
    // TODO: Scrivi il tuo codice qui sotto
    // Usa calloc() per allocare memoria per l'array
    // Verifica se l'allocazione è riuscita
    // Stampa i valori iniziali (dovrebbero essere zero)
    // Leggi e memorizza i valori di input
    // Stampa i valori aggiornati
    // Calcola e stampa la somma
    // Libera la memoria allocata
    
    return 0;
}