C array length : estimer la longueur d’un tableau en C

En utilisant dif­fé­rentes méthodes, il est possible de dé­ter­mi­ner la longueur des tableaux (array length) en C. Il est ainsi plus facile de gérer les tableaux de manière dynamique et de réagir aux chan­ge­ments de taille.

Array length in C : la longueur d’un tableau en C

La longueur d’un tableau C désigne le nombre d’éléments qu’il contient. Cette in­for­ma­tion est cruciale pour accéder à certains éléments du tableau, le parcourir ou effectuer des ma­ni­pu­la­tions. Lorsque vous déclarez un tableau en C, la mémoire pour les éléments du tableau est allouée en continu dans la RAM. En C, il n’existe pas de fonction intégrée directe pour dé­ter­mi­ner la longueur du tableau, vous devez donc la dé­ter­mi­ner ma­nuel­le­ment.

Les méthodes les plus courantes sont :

• sizeof().
• Arith­mé­tique des pointeurs.
• Boucles.

sizeof()

sizeof()fait partie des opé­ra­teurs C dans le langage de pro­gram­ma­tion C. Il détermine la taille d’un type de données ou d’une variable en octets pendant le temps de com­pi­la­tion (compile time). Le type de retour de l’opérateur sizeof est size_t, un type entier non signé qui re­pré­sente la taille en octets. La fonction sizeof() en C permet aussi de calculer la longueur d’un tableau C.

Syntaxe

Pour dé­ter­mi­ner le nombre d’éléments, il faut diviser la taille totale du tableau par la taille d’un seul élément.

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

• data_type : c’est le type de données dans lequel la longueur du tableau doit être stockée.
• array_name : spécifie le nom du tableau.
• sizeof(array_name) : cette ins­truc­tion d’ex­pres­sion renvoie la taille totale du tableau en octets.
• sizeof(array_name[index]) : en divisant la taille totale du tableau par la taille d’un seul élément, on obtient le nombre d’éléments du tableau.
• index : re­pré­sente l’index d’un élément dans le tableau.

Exemple

Ci-dessous, nous utilisons sizeof() pour dé­ter­mi­ner la taille du tableau myArray et d’un seul élément en octets, ce qui nous permet ensuite de calculer le nombre d’éléments en divisant les résultats.

#include <stdio.h>
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("Taille totale du tableau : %zu bytes\n", totalSize);
    printf("Taille d’un seul élément : %zu bytes\n", elementSize);
    printf("Nombre d’éléments dans le tableau : %zu\n", arrayLength);
    return 0;
}

La sortie est la suivante :

Taille totale du tableau : 20 bytes
Taille d’un seul élément : 4 bytes
Nombre d’éléments dans le tableau : 5

Arith­mé­tique des pointeurs

Avec l’arith­mé­tique des pointeurs, la longueur d’un tableau ne peut pas être dé­ter­mi­née di­rec­te­ment. En effet, un pointeur seul ne contient aucune in­for­ma­tion sur la taille ou la longueur du tableau associé. Mais vous pouvez utiliser les adresses des éléments du tableau pour dé­ter­mi­ner la longueur du tableau C.

Syntaxe

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

• &arr : re­pré­sente un pointeur vers un tableau d’éléments.
• (&arr + 1) : ici, le pointeur sur le tableau arr est in­cré­menté de 1. Comme arr est un tableau, cela signifie que le pointeur pointe sur le prochain tableau con­sé­cu­tif du même type que arr.

Exemple

L’ex­pres­sion *(&arr + 1) - arr calcule la dif­fé­rence entre le pointeur vers le prochain tableau &arr + 1 et le pointeur vers le premier élément du tableau initial. Dans ce cas, la zone mémoire « suivante » est la fin du tableau. La dif­fé­rence ré­sul­tante est égale au nombre d’éléments du tableau.

#include <stdio.h>
int main() {
int arr[] = {1, 2, 3, 4, 5};
    int length = *(&arr + 1) - arr;
    printf("Nombre d’éléments dans le tableau : %d\n", length);
    return 0;
}

Sortie :

Nombre d’éléments dans le tableau : 5

Boucles

Une autre méthode consiste à dé­ter­mi­ner la longueur du tableau avec une boucle For. Celle-ci itère dans le tableau et compte combien d’éléments il contient. Pour cela, le tableau doit être déclaré dans le même domaine de validité (scope) que celui dans lequel le code de dé­ter­mi­na­tion de la longueur est exécuté.

Exemple

Ici, la boucle in­cré­mente le compteur arrayLength pour chaque élément parcouru. La condition i < sizeof(arr) / sizeof(arr[0]) assure que la boucle ne s’exécute que tant qu’il y a ef­fec­ti­ve­ment des éléments dans le tableau.

#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("Nombre d’éléments dans le tableau : %d\n", arrayLength);
    return 0;
}

Sortie :

Nombre d’éléments dans le tableau : 8