De­ter­mi­na­re la lunghezza di un array in C: i metodi migliori

La lunghezza degli array in C può essere de­ter­mi­na­ta uti­liz­zan­do vari metodi che con­sen­to­no di sem­pli­fi­ca­re la gestione dinamica degli array e di reagire alle va­ria­zio­ni di di­men­sio­ne.

Lunghezza di un array in C

La lunghezza di un array C si riferisce al numero di elementi che contiene. Questa in­for­ma­zio­ne è cruciale per accedere a elementi specifici nell’array, per at­tra­ver­sar­lo o per ef­fet­tua­re ma­ni­po­la­zio­ni. Quando viene di­chia­ra­to un array, la memoria per i suoi elementi viene allocata in modo continuo nella RAM. In C non esiste una funzione integrata diretta per de­ter­mi­na­re la lunghezza di un array, quindi è ne­ces­sa­rio farlo ma­nual­men­te.

I metodi più comuni includono:

• sizeof()
• Arit­me­ti­ca dei puntatori
• Cicli

sizeof()

sizeof()fa parte degli operatori del lin­guag­gio di pro­gram­ma­zio­ne C. La sua funzione è de­ter­mi­na­re la di­men­sio­ne di un tipo di dati o di una variabile in byte durante la com­pi­la­zio­ne. Il valore di ritorno dell’operatore sizeof è size_t, un tipo di intero senza segno che rap­pre­sen­ta la di­men­sio­ne in byte. L’operatore sizeof può anche essere uti­liz­za­to per calcolare la lunghezza di un array.

Sintassi

Per de­ter­mi­na­re il numero di elementi, è ne­ces­sa­rio dividere la di­men­sio­ne totale dell’array per la di­men­sio­ne di un singolo elemento.

data_type arrayLength = sizeof(array_name) / sizeof(array_name[index]);

• data_type: si tratta del tipo di dati in cui deve essere salvata la lunghezza dell’array.
• array_name: specifica il nome dell’array.
• sizeof(array_name): re­sti­tui­sce la di­men­sio­ne totale dell’array in byte.
• sizeof(array_name[index]): re­sti­tui­sce il numero di elementi dell’array dividendo la di­men­sio­ne totale dell’array per la di­men­sio­ne di un singolo elemento.
• index: indica l’indice di un elemento dell’array.

Esempio

Uti­liz­zia­mo sizeof() in un esempio pratico per de­ter­mi­na­re la di­men­sio­ne dell’array myArray e di un singolo elemento in byte, in modo da poter calcolare il numero di elementi at­tra­ver­so la divisione dei risultati.

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    size_t totalSize = sizeof(myArray);
    size_t elementSize = sizeof(myArray[0]);
    size_t arrayLength = totalSize / elementSize;
    printf("Total size of the array: %d bytes\n", (int)totalSize);
    printf("Size of a single element: %d bytes\n", (int)elementSize);
    printf("Number of elements in the array: %d\n", (int)arrayLength);
    return 0;
}

Il risultato è il seguente:

Total size of the array: 20 bytes
Size of a single element: 4 bytes
Number of elements in the array: 5

Arit­me­ti­ca dei puntatori

La lunghezza di un array non può essere de­ter­mi­na­ta di­ret­ta­men­te uti­liz­zan­do l’arit­me­ti­ca dei puntatori, poiché un puntatore da solo non contiene in­for­ma­zio­ni sulla di­men­sio­ne o lunghezza dell’array associato. Tuttavia, per de­ter­mi­na­re la lunghezza dell’array è possibile uti­liz­za­re gli indirizzi dei suoi elementi.

Sintassi

data_type arr_length = *(&arr + 1) - arr;

• &arr: rap­pre­sen­ta un puntatore a un array di elementi.
• (&arr + 1): in questo caso, il puntatore all’array arr è in­cre­men­ta­to di 1. Essendo arr un array, ciò significa che il puntatore punta all’array suc­ces­si­vo dello stesso tipo.

Esempio

L’espres­sio­ne *(&arr + 1) - arr calcola la dif­fe­ren­za tra il puntatore all’array suc­ces­si­vo &arr + 1 e il puntatore al primo elemento dell’array originale. In questo caso, l’area di memoria “suc­ces­si­va” cor­ri­spon­de alla fine dell’array. La dif­fe­ren­za ri­sul­tan­te è uguale al numero di elementi nell’array.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int length = *(&arr + 1) - arr;
    printf("Number of elements in the array: %d\n", length);
    return 0;
}

Il risultato è il seguente:

Number of elements in the array: 5

Cicli

Un ulteriore metodo per de­ter­mi­na­re la lunghezza di un array in C è quello di uti­liz­za­re un ciclo for. Questo ciclo itera at­tra­ver­so l’array e conta quanti elementi esso contiene. Per fare ciò, l’array deve essere di­chia­ra­to nello stesso ambito in cui viene eseguito il codice per de­ter­mi­nar­ne la lunghezza.

Esempio

In questo ciclo, il contatore arrayLength viene in­cre­men­ta­to per ogni elemento at­tra­ver­sa­to. La con­di­zio­ne i < sizeof(arr) / sizeof(arr[0]) ga­ran­ti­sce che il ciclo venga eseguito solo finché ci sono ef­fet­ti­va­men­te elementi nell’array.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t arrayLength = 0;
    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
        arrayLength++;
    }
    printf("Number of elements in the array: %d\n", arrayLength);
    return 0;
}

Si ottiene il seguente risultato:

Number of elements in the array: 8