HOWTO · C
for-each boucle en C
Le contenu suivant examinera si le langage informatique C prend en charge ou non une boucle foreach.
Sur cette page
Le C ne possède pas de boucle for-each intégrée qui parcourt automatiquement chaque élément d’une collection. Vous pouvez obtenir le même style de parcours avec une boucle for ou while classique, mais votre code doit savoir où la collection se termine. Pour un tableau, conservez le nombre d’éléments ; pour une liste chaînée, suivez le pointeur next de chaque nœud jusqu’à ce qu’il soit nul.
Le C possède-t-il une boucle foreach intégrée ?
Non. Le langage C ne fournit pas de construction foreach dédiée comme celles de Python ou de JavaScript. Il reste facile d’écrire une boucle de type for-each lorsque la collection et ses limites sont clairement définies. Pour un tableau, une boucle indicée est un choix courant. Pour une liste chaînée, faites avancer un pointeur de nœud en nœud.
La différence essentielle avec de nombreux langages de plus haut niveau est que le C n’associe pas de longueur à un pointeur vers un tableau. Lorsqu’une fonction doit traiter un tableau, transmettez sa longueur avec le pointeur. La condition d’arrêt est ainsi explicite et évite de lire au-delà des éléments qui appartiennent à la collection.
Parcourir un tableau avec une boucle for
Pour un tableau déclaré dans la même portée, calculez son nombre d’éléments avec sizeof array / sizeof array[0]. Utilisez ensuite un indice qui va de zéro jusqu’à ce nombre, sans l’inclure.
Le programme autonome suivant affiche chaque élément dans l’ordre. Cette expression de longueur est valide ici, car numbers est encore un tableau dans main.
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#include <stddef.h>
#include <stdio.h>
int main(void) {
int numbers[] = {10, 20, 30, 40, 50};
size_t length = sizeof numbers / sizeof numbers[0];
for (size_t i = 0; i < length; ++i) {
printf("%d\n", numbers[i]);
}
return 0;
}
10
20
30
40
50
Lorsque vous transmettez un tableau à une fonction, son paramètre est un pointeur vers le premier élément ; la taille du tableau ne l’accompagne pas. Par conséquent, appliquer sizeof à ce paramètre renvoie la taille du pointeur, et non la taille en octets du tableau d’origine. Transmettez séparément le nombre d’éléments, par exemple avec size_t length, puis parcourez le tableau tant que i < length. L’appelant peut calculer ce nombre avant de transmettre le tableau. Pour un tableau alloué dynamiquement, conservez le nombre d’éléments obtenu lors de l’allocation ou auprès de la structure qui le gère.
Utiliser une boucle while ou parcourir une liste chaînée
Une boucle while convient tout aussi bien lorsque sa condition permet naturellement de déterminer s’il reste un élément. Pour un tableau, initialisez un indice à zéro, continuez tant qu’il est inférieur à la longueur enregistrée et incrémentez-le une fois par itération. Comme avec une boucle for, cette limite est importante.
Une liste chaînée utilise une autre condition d’arrêt : continuez tant que le pointeur vers le nœud courant n’est pas nul, traitez ce nœud, puis passez à current->next. Par exemple, un nœud peut être déclaré ainsi : struct Node { int value; struct Node *next; };. Comme current est un pointeur vers un nœud, accédez à ses champs avec ->. La liste se termine lorsque current devient NULL. N’utilisez pas la formule sizeof d’un tableau pour une liste chaînée : ses nœuds sont des objets distincts reliés par des pointeurs, et la liste n’a pas de longueur de tableau. Si vous devez compter ses nœuds, parcourez-la ou conservez un compteur dans la structure qui la gère.
Quand faut-il encapsuler le parcours dans une fonction ou une macro ?
Une fonction est utile lorsque plusieurs parties d’un programme effectuent la même opération sur chaque élément d’un tableau. Elle peut recevoir un pointeur vers les éléments, un nombre d’éléments de type size_t et l’opération à appliquer. Un paramètre de rappel pourrait avoir le type void (*visit)(int) ; la fonction appellerait alors visit(array[i]) pour chaque indice valide. Transmettez explicitement le nombre d’éléments : dans la fonction, le paramètre tableau est un pointeur, et sizeof ne permet donc pas de retrouver la taille d’origine.
Une fonction qui reçoit un rappel peut aussi appliquer différentes opérations, comme afficher ou accumuler des valeurs. Faites correspondre le type du rappel à celui des éléments et déterminez s’il a besoin d’un contexte supplémentaire ; en C, les rappels peuvent recevoir ce contexte au moyen d’un paramètre void *.
Une macro peut rendre une boucle plus concise, mais elle effectue une substitution textuelle et peut évaluer ses arguments plusieurs fois. Elle peut aussi masquer les limites et les types qui rendent le parcours sûr. Si vous en utilisez une, vérifiez que la limite correspond au tableau et évitez de lui transmettre des expressions ayant des effets de bord. Pour du code réutilisable, une fonction avec une longueur explicite est généralement plus facile à examiner, à déboguer et à maintenir.