Introduction
Si tu as déjà travaillé avec le langage C, tu as sûrement rencontré les types de tableaux et leur comportement parfois déroutant. Un tableau de type T[n] est distinct d'un pointeur de type T*, mais dans de nombreux cas pratiques, les tableaux se comportent comme des pointeurs. Cela peut compliquer la vie des développeurs, notamment lorsqu'il s'agit de comprendre la taille des tableaux ou de passer des tableaux en argument de fonction.
Tableaux vs. Pointeurs
Techniquement, un tableau T[n] représente une séquence contiguë de valeurs T en mémoire. Cependant, dans la plupart des expressions, ce type est immédiatement converti en un pointeur vers le premier élément du tableau. Cela signifie que l'opérateur d'indexation des tableaux arr[ix] fonctionne en réalité sur des pointeurs, comme *(arr + ix). Une exception notable est l'utilisation de sizeof qui, lorsqu'il est appliqué à un tableau, retourne la taille totale du tableau, soit sizeof(T) × n.
``c int arr[3] = {10, 20, 30}; int *arr_ptr = arr; size_t arr_size = sizeof(arr); // Retourne la taille totale size_t ptr_size = sizeof(arr_ptr); // Retourne la taille du pointeur ``
Tableaux en Arguments de Fonction
Lorsqu'un tableau est passé en argument de fonction, il est converti en pointeur, et la taille du tableau est perdue. Cela peut mener à des comportements inattendus, comme dans l'exemple suivant :
```c size_t foo(char buf[6]) { return sizeof(buf); // Retourne la taille d'un pointeur }
char msg[6] = "Hello"; size_t msg_size = sizeof(msg); // Retourne 6 size_t msg_size_in_fn = foo(msg); // Retourne la taille d'un pointeur ```
Pour contourner ce problème, tu peux passer un pointeur vers le tableau, ce qui préserve l'information de longueur.
```c size_t foo(char (buf)[6]) { return sizeof(buf); // Retourne 6 }
char msg[6] = "Hello"; size_t msg_size_in_fn = foo(&msg); // Retourne 6 ```
Similitudes avec les Fonctions
Les fonctions en C partagent un comportement similaire avec les tableaux en ce sens qu'elles se convertissent immédiatement en pointeurs de fonction. Toutefois, la déférence d'un pointeur de fonction permet toujours d'appeler la fonction.
``c void foo() {} (*foo)(); // Appelle la fonction foo(); // Appelle également la fonction ``
Pourquoi Est-ce Important ?
Pour les développeurs, comprendre ces subtilités est crucial pour écrire du code C robuste et éviter des bugs difficiles à diagnostiquer. Par exemple, une mauvaise gestion des tailles de tableaux peut mener à des débordements de buffer, une des principales failles de sécurité.
Conclusion
Malgré leur complexité, les types de tableaux en C sont puissants et flexibles. En maîtrisant leur comportement, tu peux tirer parti de leur efficacité tout en évitant les pièges courants. Discutons de ton projet en 15 minutes.
Reference
- Anselm Schueler, "C array types are weird", [anselmschueler.com](https://anselmschueler.com/blogposts/2025-c-pointers/)