C Academy · Lezione

Allocare un array

Riservi memoria nell'heap.

Allocare un array è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Perché gli array dinamici?

Un array normale ha una dimensione fissa, stabilita al momento della compilazione. Spesso, però, il numero di elementi necessari non è noto finché il programma non è in esecuzione.

Gli array dinamici risolvono questo problema: si richiede al sistema operativo un blocco di memoria durante l'esecuzione usando malloc e si determina la dimensione tramite una variabile.

Conoscere malloc

malloc (memory allocate) si trova in <stdlib.h>. Le si passa un numero di byte e restituisce un puntatore al blocco, oppure NULL in caso di errore.

La memoria proviene dall'heap e rimane disponibile finché non la si libera.

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

Determinare la dimensione con sizeof

Non codifichi mai direttamente il numero di byte. Utilizzi sizeof per mantenere corretto il codice su piattaforme diverse.

Per allocare spazio per n interi, moltiplichi n per sizeof(int). Un idioma comune è n * sizeof(*p), che utilizza il tipo del puntatore stesso.

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

Controllare sempre NULL

Se il sistema non ha memoria disponibile, malloc restituisce NULL. Dereferenziare un puntatore NULL provoca l'arresto del programma.

Controlli il risultato prima di utilizzarlo. Questa semplice abitudine previene molti errori difficili da individuare.

int *p = malloc(n * sizeof(*p));
if (p == NULL) {
    fprintf(stderr, "out of memory\n");
    return 1;
}

Un'allocazione completa

Ecco un programma completo che alloca spazio per 5 interi, li riempie e li stampa.

Noti la simmetria: malloc all'inizio e free alla fine.

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

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

malloc non azzera la memoria

La memoria restituita da malloc non è inizializzata: contiene qualunque dato fosse presente in precedenza.

Leggerla prima di avervi scritto produce valori imprevedibili. Assegni sempre un valore a ogni elemento prima di leggerlo.

int *a = malloc(3 * sizeof(*a));
/* a[0], a[1], a[2] hold garbage here */
a[0] = 10;

calloc azzera la memoria

calloc(count, size) alloca spazio per count elementi di size byte e imposta ogni byte a zero.

Lo si utilizzi quando si desidera un array pulito e inizializzato a zero. Inoltre protegge dal traboccamento durante la moltiplicazione.

int *a = calloc(5, sizeof(*a));
/* every element is now 0 */

calloc in azione

Questo programma usa calloc e verifica che l'array inizi contenendo zeri prima di modificarlo.

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

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

Indicizzare il blocco

Un puntatore a un blocco nell'heap si comporta proprio come il nome di un array. È possibile usare a[i] per leggere e scrivere qualsiasi elemento da 0 a n-1.

Internamente, a[i] equivale a *(a + i).

int *a = malloc(3 * sizeof(*a));
a[0] = 1;
*(a + 1) = 2;   /* same as a[1] = 2 */
a[2] = 3;

Attenzione ai limiti

Se si allocano n elementi, gli indici validi vanno da 0 a n-1. Scrivere in a[n] produce un comportamento non definito.

C non controlla i limiti al posto Suo, quindi un errore di indice di una posizione può danneggiare silenziosamente la memoria.

int *a = malloc(3 * sizeof(*a));
a[2] = 99;   /* OK, last valid index */
/* a[3] = 0;  BUG: out of bounds */

Leggere la dimensione durante l'esecuzione

Il vero vantaggio è che la dimensione può provenire da un input, da un file o da un calcolo. Lo stesso codice può allocare 2 o 2 milioni di elementi.

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

int main(void) {
    int n = 6;            /* could be scanf'd */
    long *a = malloc(n * sizeof(*a));
    if (!a) return 1;
    long sum = 0;
    for (int i = 0; i < n; i++) { a[i] = i + 1; sum += a[i]; }
    printf("%ld\n", sum);
    free(a);
    return 0;
}

Verifica rapida

Verifichi la propria comprensione dell'allocazione.

Riepilogo

Si alloca un array dinamico con malloc(n * sizeof(*p)) oppure lo si inizializza a zero con calloc(n, sizeof(*p)).

Controlli sempre NULL, ricordi che malloc lascia dati non inizializzati, indicizzi da 0 a n-1 e associ ogni allocazione a una free. Ora imparerà a ridimensionare un blocco mantenendone i dati.

Domande Frequenti

La lezione «Allocare un array» è gratuita?

Sì — il testo completo di «Allocare un array» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Allocare un array»?

Riservi memoria nell'heap. Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Allocare un array»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C Academy