Ottieni la dimensione di un array in C

Per un array di dimensione fissa nello stesso ambito, dividi la sua dimensione totale in byte per la dimensione in byte di un elemento: sizeof array / sizeof array[0]. Il risultato è il numero di elementi. All’interno di una funzione, passa quel conteggio separatamente, perché un parametro array viene trattato come un puntatore.

Usare sizeof per contare gli elementi in un array di dimensione fissa

sizeof restituisce una dimensione in byte. Per un array visibile nell’ambito corrente, sizeof values è la dimensione dell’intero array, mentre sizeof values[0] è la dimensione di un elemento. Il loro quoziente fornisce il conteggio degli elementi senza presumere che un int abbia una particolare dimensione in byte.

Questo esempio completo in C conta un array di dimensione fissa e passa il risultato a una funzione. I valori e la chiamata di funzione mostrano come adattare lo schema a un altro tipo di elemento o a un altro array.

#include <stdio.h>
#include <stddef.h>

void print_values(const int *values, size_t count)
{
    size_t i;
    printf("Element count: %d\n", (int)count);
    for (i = 0; i < count; ++i) {
        printf("%d ", values[i]);
    }
    putchar('\n');
}

int main(void)
{
    int values[] = {4, 8, 15, 16};
    size_t count = sizeof values / sizeof values[0];

    printf("Array count: %d\n", (int)count);
    print_values(values, count);
    return 0;
}

Array count: 4
Element count: 4
4 8 15 16

Per questa dimostrazione, la conversione a int è sicura perché l’array ha quattro elementi. Per un conteggio generale, usa un specificatore di formato adatto a size_t nella libreria C di destinazione.

Perché sizeof restituisce la dimensione del puntatore all’interno di una funzione

Nella dichiarazione di un parametro di funzione, int values[] viene convertito in int *values. Pertanto, sizeof values in quella funzione misura il puntatore, non l’array del chiamante. Dividere quel valore per sizeof values[0] non recupera il numero originale di elementi, e la dimensione del puntatore può variare in base alla piattaforma.

Mantieni il calcolo del conteggio dell’array nell’ambito in cui l’array è dichiarato, poi passa il conteggio a qualsiasi funzione ne abbia bisogno. Questo vale per i normali parametri array così come per i parametri scritti con la sintassi del puntatore.

Usare una macro per gli array nello stesso ambito

Una macro può rendere riutilizzabile il calcolo nello stesso ambito: #define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])). Usala dove array è un array effettivo, come ARRAY_SIZE(values) nell’ambito che dichiara values. Quando un array viene passato a una funzione, la macro vede un puntatore e non può determinare la lunghezza originale dell’array. Per gli array multidimensionali, l’espressione conta gli elementi nella dimensione più esterna.

Passare il conteggio degli elementi a una funzione

Dichiara il parametro della funzione come puntatore (o parametro array) e fornisci un conteggio size_t separato, come fa print_values(values, count) sopra. Il chiamante calcola il conteggio mentre l’intero array è nell’ambito; la funzione usa quel conteggio come limite del suo ciclo. Questo schema funziona per gli array di dimensione fissa e per la memoria allocata dinamicamente, purché il chiamante fornisca il numero di elementi. Mantieni insieme puntatore e conteggio in modo che la funzione elabori esattamente gli elementi previsti.