Guida C interattiva: Array

Q: Come si dichiara un array in C?

Indica il tipo degli elementi, un nome e una dimensione tra parentesi quadre: int scores[5]; riserva spazio per cinque int. La dimensione deve essere una costante nota nel punto in cui dichiari l'array (a parte gli array a lunghezza variabile) e gli elementi partono non inizializzati, a meno che tu non fornisca dei valori.

Q: Come si trova la lunghezza di un array in C?

sizeof(arr) / sizeof(arr[0]): la dimensione totale in byte divisa per la dimensione di un elemento. Funziona solo nello scope in cui l'array è stato dichiarato: una volta passato a una funzione, l'array è decaduto a puntatore e sizeof misura il puntatore.

Q: Cosa succede se vai oltre la fine di un array in C?

Niente ti ferma. C non controlla i limiti, quindi arr[10] su un array di 5 elementi legge o scrive qualunque cosa si trovi in quella memoria. È comportamento indefinito: può stampare valori spazzatura, corrompere un'altra variabile o mandare in crash il programma, e può sembrare funzionare finché non smette di farlo.

Q: Come si inizializzano a zero tutti gli elementi di un array in C?

int arr[100] = {0};: tutti gli elementi che non elenchi vengono inizializzati a zero, quindi un solo zero azzera l'intero array. In C23 funziona anche int arr[100] = {};. Senza alcun inizializzatore, il contenuto di un array locale è spazzatura indeterminata.

Un array è un blocco di dimensione fissa di elementi dello stesso tipo, disposti uno dopo l'altro in memoria. Tutto dipende da questa disposizione contigua: è il motivo per cui l'accesso tramite indice è immediato, per cui array e puntatori sono così legati e per cui C può darti l'indirizzo dell'elemento zero e lasciarti trovare gli altri con l'aritmetica.

Dichiarare un array

Tipo degli elementi, nome e una dimensione tra parentesi quadre:

int    scores[5];       // 5 ints
double prices[100];     // 100 doubles
char   initials[3];     // 3 chars

La dimensione è il numero di elementi e deve essere nota nel punto in cui l'array viene dichiarato: di solito è un letterale o una costante definita con #define. La memoria viene riservata subito, non c'è nessuna allocazione successiva.

Un array locale appena dichiarato contiene spazzatura, non zeri:

#include <stdio.h>

int main(void) {
    int uninitialized[5];        // il contenuto è indeterminato
    int zeroed[5] = {0};         // ogni elemento vale 0

    printf("azzerato:           ");
    for (int i = 0; i < 5; i++) printf("%d ", zeroed[i]);

    printf("\nnon inizializzato:  ");
    for (int i = 0; i < 5; i++) printf("%d ", uninitialized[i]);
    printf("   <-- quello che c'era in quella memoria\n");

    return 0;
}

La seconda riga può stampare zeri, numeri enormi, e può cambiare tra un'esecuzione e l'altra o tra una build di debug e una di release. Leggere quei valori è comportamento indefinito: inizializza prima di leggere.

Inizializzazione

Diverse forme, tutte utili:

#include <stdio.h>

int main(void) {
    int a[5] = {10, 20, 30, 40, 50};   // lista completa
    int b[5] = {1, 2};                 // il resto viene riempito con zeri: 1 2 0 0 0
    int c[5] = {0};                    // tutto l'array vale zero
    int d[]  = {7, 8, 9};              // dimensione dedotta: 3 elementi
    int e[5] = {[4] = 99, [0] = 1};    // inizializzatori designati (C99)

    int n = sizeof d / sizeof d[0];

    printf("a: "); for (int i = 0; i < 5; i++) printf("%d ", a[i]);
    printf("\nb: "); for (int i = 0; i < 5; i++) printf("%d ", b[i]);
    printf("\nc: "); for (int i = 0; i < 5; i++) printf("%d ", c[i]);
    printf("\nd: "); for (int i = 0; i < n; i++) printf("%d ", d[i]);
    printf("  (dimensione dedotta: %d)", n);
    printf("\ne: "); for (int i = 0; i < 5; i++) printf("%d ", e[i]);
    printf("\n");

    return 0;
}

L'idioma da ricordare è {0}: tutti gli elementi che non elenchi vengono inizializzati a zero, quindi un solo zero azzera l'intero array. Gli inizializzatori designati ([4] = 99) ti permettono di impostare posizioni specifiche e lasciare il resto a zero, comodo per tabelle di lookup quasi vuote.

Una cosa che non puoi fare è assegnare un array dopo la dichiarazione:

int a[3] = {1, 2, 3};
int b[3];
b = a;                    // errore: un array non è assegnabile
memcpy(b, a, sizeof a);   // così si copia un array

Gli indici partono da zero

Il primo elemento è arr[0] e l'ultimo è arr[n-1]. Non esiste arr[n].

#include <stdio.h>

int main(void) {
    int scores[5] = {88, 92, 75, 60, 100};

    printf("primo    scores[0] = %d\n", scores[0]);
    printf("terzo    scores[2] = %d\n", scores[2]);
    printf("ultimo   scores[4] = %d\n", scores[4]);

    scores[1] = 95;                       // scrittura in un elemento
    printf("dopo la modifica, scores[1] = %d\n", scores[1]);

    printf("\nindirizzi (nota la spaziatura regolare):\n");
    for (int i = 0; i < 5; i++) {
        printf("  scores[%d] a %p\n", i, (void *)&scores[i]);
    }

    return 0;
}

Esegui l'ultimo ciclo e guarda gli indirizzi: ognuno si trova esattamente sizeof(int) byte dopo il precedente. Gli elementi sono davvero disposti uno dopo l'altro:

 indice     0         1         2         3         4
         +--------+--------+--------+--------+--------+
 valore  |   88   |   95   |   75   |   60   |  100   |
         +--------+--------+--------+--------+--------+
 offset   +0       +4       +8       +12      +16      byte
          ^
          &scores[0], che è anche ciò a cui `scores` decade

L'indicizzazione da zero non è una scelta arbitraria: rende l'indice un offset dall'inizio, che è proprio ciò che serve all'aritmetica degli indirizzi. scores[i] è definito come *(scores + i); vedi puntatori e array.

Trovare la lunghezza

C non memorizza da nessuna parte la lunghezza di un array a runtime, ma il compilatore la conosce e sizeof ti dà accesso a questa informazione:

#include <stdio.h>

int main(void) {
    double prices[] = {4.99, 12.50, 0.99, 7.25};

    printf("byte totali       = %zu\n", sizeof prices);
    printf("byte per elemento = %zu\n", sizeof prices[0]);
    printf("lunghezza         = %zu\n", sizeof prices / sizeof prices[0]);

    return 0;
}

L'idioma è sizeof(arr) / sizeof(arr[0]). Dividere per arr[0] invece che per un sizeof(double) scritto a mano fa sì che la riga continui a funzionare se cambi il tipo degli elementi.

La trappola: funziona solo dove l'array è stato dichiarato. Passa l'array a una funzione e il parametro diventa un puntatore, quindi sizeof misura il puntatore: di solito 8 byte, che danno una "lunghezza" di 1 o 2. Ecco perché ogni funzione C che riceve un array riceve anche un conteggio:

#include <stdio.h>

int sum(const int *arr, int n) {       // la lunghezza va passata come argomento
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];   // calcolata QUI, dove è corretta

    printf("lunghezza = %d\n", n);
    printf("somma     = %d\n", sum(data, n));

    return 0;
}

Scorrere un array con un ciclo

La forma standard è un ciclo for che parte da 0 e continua finché i < n:

#include <stdio.h>

int main(void) {
    int temps[7] = {18, 21, 25, 22, 19, 17, 24};
    int n = sizeof temps / sizeof temps[0];

    int total = 0, hottest = temps[0], coldest = temps[0];

    for (int i = 0; i < n; i++) {
        total += temps[i];
        if (temps[i] > hottest) hottest = temps[i];
        if (temps[i] < coldest) coldest = temps[i];
    }

    printf("letture: ");
    for (int i = 0; i < n; i++) printf("%d ", temps[i]);

    printf("\nmedia:   %.1f\n", (double)total / n);
    printf("massima: %d\n", hottest);
    printf("minima:  %d\n", coldest);

    return 0;
}

Nota i < n, non i <= n. Con n elementi gli indici validi vanno da 0 a n - 1, quindi <= esegue un passaggio in più e legge oltre la fine. Inizializzare hottest e coldest con temps[0] invece che con 0 è l'altra abitudine da copiare: far partire un massimo da zero si rompe in silenzio con dati tutti negativi.

Uscire dai limiti è comportamento indefinito

Questa è la parte di C che sorprende chi arriva da altri linguaggi. Non c'è alcun controllo dei limiti. Né in compilazione né a runtime. arr[10] su un array di cinque elementi non è un errore: è un calcolo di indirizzo che il compilatore esegue senza commenti.

int arr[5] = {1, 2, 3, 4, 5};
arr[7] = 99;     // scrive 8 byte oltre la fine dell'array
int x = arr[-1]; // legge prima dell'inizio

Quello che succede dopo è comportamento indefinito, e i sintomi sono vari in modo poco utile:

sembra funzionare, perché la memoria colpita non era usata;
un'altra variabile cambia senza un motivo visibile;
il programma va in crash con un segmentation fault, magari molto più tardi;
il comportamento cambia tra -O0 e -O2.

"Sembra funzionare" è il caso pericoloso, perché significa che il bug finisce in produzione. Tre difese:

Cicla con i < n. La maggior parte degli sforamenti sono errori di uno nella condizione di un ciclo.
Valida gli indici che arrivano dall'input.

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;

    int requests[4] = {2, 5, -1, 4};    // due di questi sono fuori intervallo

    for (int i = 0; i < 4; i++) {
        int idx = requests[i];
        if (idx >= 0 && idx < n) {
            printf("arr[%d] = %d\n", idx, arr[idx]);
        } else {
            printf("indice %d rifiutato (l'intervallo valido e' 0..%d)\n", idx, n - 1);
        }
    }

    return 0;
}

Compila con un sanitizer mentre sviluppi. gcc -fsanitize=address -g prog.c trasforma la maggior parte degli sforamenti in una segnalazione immediata che indica il file, la riga e l'array coinvolto.

Array di altri tipi

La stessa sintassi funziona con qualsiasi tipo di elemento, comprese le struct:

#include <stdio.h>

typedef struct {
    const char *name;
    int         score;
} Player;

int main(void) {
    Player players[3] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Ken",   85}
    };
    int n = sizeof players / sizeof players[0];

    for (int i = 0; i < n; i++) {
        printf("%-6s %3d\n", players[i].name, players[i].score);
    }

    // un array di char è una stringa quando termina con '\0'
    char word[6] = "hello";        // 5 caratteri più il terminatore
    printf("\nword = %s (%zu byte di spazio)\n", word, sizeof word);

    return 0;
}

Vale la pena soffermarsi sulla riga char word[6] = "hello";: una stringa in C è semplicemente un array di char il cui ultimo byte significativo è '\0'. Quel terminatore è il motivo per cui l'array ha bisogno di sei posizioni per cinque lettere.

Array a lunghezza variabile, in breve

C99 permette un array la cui dimensione è un valore a runtime:

int n = get_count();
int buffer[n];        // un array a lunghezza variabile

Due avvertenze. La dimensione è fissa una volta creato l'array, quindi un VLA non è una lista che può crescere. E la memoria arriva dallo stack, quindi un n grande o controllato da un attaccante può farlo traboccare e mandare in crash il programma: è per questo che molti progetti, compreso il kernel Linux, vietano del tutto i VLA. Inoltre in C11 il loro supporto è facoltativo per le implementazioni.

Quando la dimensione è davvero sconosciuta fino al runtime, alloca la memoria:

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

int main(void) {
    int n = 6;                              // immagina che arrivi dall'input

    int *arr = malloc(n * sizeof *arr);     // heap, non stack
    if (arr == NULL) {
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = (i + 1) * (i + 1);
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);              // l'indicizzazione funziona allo stesso modo
    }
    printf("\n");

    free(arr);
    return 0;
}

Nota che arr[i] si legge allo stesso modo sia che arr sia un array sia che sia un puntatore a memoria allocata: la sintassi di indicizzazione non fa differenza. Tutti i dettagli nella memoria dinamica.

Domande frequenti

Come si dichiara un array in C?

Indica il tipo degli elementi, un nome e una dimensione tra parentesi quadre: int scores[5]; riserva spazio per cinque int. La dimensione deve essere una costante nota nel punto in cui dichiari l'array (a parte gli array a lunghezza variabile) e gli elementi partono non inizializzati, a meno che tu non fornisca dei valori.

Come si trova la lunghezza di un array in C?

sizeof(arr) / sizeof(arr[0]): la dimensione totale in byte divisa per la dimensione di un elemento. Funziona solo nello scope in cui l'array è stato dichiarato: una volta passato a una funzione, l'array è decaduto a puntatore e sizeof misura il puntatore.

Cosa succede se vai oltre la fine di un array in C?

Niente ti ferma. C non controlla i limiti, quindi arr[10] su un array di 5 elementi legge o scrive qualunque cosa si trovi in quella memoria. È comportamento indefinito: può stampare valori spazzatura, corrompere un'altra variabile o mandare in crash il programma, e può sembrare funzionare finché non smette di farlo.

Come si inizializzano a zero tutti gli elementi di un array in C?

int arr[100] = {0};: tutti gli elementi che non elenchi vengono inizializzati a zero, quindi un solo zero azzera l'intero array. In C23 funziona anche int arr[100] = {};. Senza alcun inizializzatore, il contenuto di un array locale è spazzatura indeterminata.

Concetti correlati