Programmation C source/itérations
int main(void)
 printf("----------------------------------------\n");
 printf(" Boucle for\n");
 printf("----------------------------------------\n");
 #if 0
 for (initialisation ; condition ; itération)
 bloc
 #endif
 /* Une boucle for commence par l' initialisation, puis exécute le bloc de code tant
 que la condition est vérifiée et en appelant l'itération après chaque bloc. */
 int i;
 for (i = 0; i < 3; i++)
 printf("i = %d\n", i);
 /* La norme C99 permet maintenant de déclarer des variables dans la partie
 initialisation de la boucle for. Ces variables ne peuvent qu'être de classe
 automatic ou register. Leur portée est limitée à la boucle. Elles n'interfèrent
 pas avec les variables de même nom déclarées en dehors de la boucle. Leur
 utilisation pourrait conduire à de possibles optimisations du code par le
 compilateur. */
 // En C99 :
 for (int j = 0; j < 3; j++)
 printf("j = %d\n", j);
 // Le bloc de code étant réduit à une instruction, on aurait pu écrire :
 for (int k = 0; k < 3; k++)
 printf("k = %d\n", k);
 int l = 0;
 for( ; l != 1; l = rand() % 4)
 printf("je continue\n");
 /* cet exemple montre plusieurs choses :
 1. l'initialisation de la boucle a été omise, en fait n'importe laquelle des trois
 parties peut l'être (et même les trois à la fois, ce qui résulte en une boucle
 infinie) ;
 2. l'expression itération est réellement une expression, on peut y faire appel à
 des fonctions ;
 3. le nombre d'itérations n'est pas fixe, le programme affichera « je continue »
 un nombre (pseudo-)aléatoire de fois. */
 printf("\n----------------------------------------\n");
 printf(" Boucle while\n");
 printf("----------------------------------------\n");
 #if 0
 while (condition)
 bloc
 #endif
 // Une boucle while exécute le bloc d'instructions tant que la condition est vérifiée.
 int m = 0;
 while (m < 3)
 printf("m = %d\n", m);
 m = m + 1;
 printf("\n----------------------------------------\n");
 printf(" Boucle do-while\n");
 printf("----------------------------------------\n");
 #if 0
 do
 bloc
 while (condition);
 #endif
 /* Cette boucle est une légère variante de la précédente. Elle exécute donc le bloc
 au moins une fois, et ce jusqu'à ce que la condition soit fausse (ou tant que la
 condition est vraie). */
 int n = 0;
 do
 printf("n = %d\n", n);
 n = n + 1;
 } while (n < 3);
 char c;
 do
 printf("Veuillez taper la lettre 'o'\n");
 scanf("%c", &c);
 getchar();
 } while (c != 'o');
 /* Tant que l'utilisateur n'aura pas tapé la lettre o, le programme redemandera de
 taper la lettre. */
 printf("\n----------------------------------------\n");
 printf(" Arrêt et continuation des boucles\n");
 printf("----------------------------------------\n");
 /* Il arrive fréquemment qu'en évaluant un test à l'intérieur d'une boucle, on
 aimerait arrêter brutalement la boucle ou alors « sauter » certains cas non
 significatifs. C'est le rôle des instructions break et continue. */
 /* break permet de sortir immédiatement d'une boucle for, while ou do-while. À noter
 que si la boucle se trouve elle-même dans une autre boucle, seule la boucle où le
 l'instruction break se trouvait est stoppée. */
 /* continue permet de recommencer la boucle depuis le début du bloc. Dans le cas de
 la boucle for, le bloc lié à l'incrémentation sera exécuté, puis dans tous les
 cas, la condition sera testée. */
 printf("\n----------------------------------------\n");
 printf(" Saut inconditionnel (goto)\n");
 printf("----------------------------------------\n");
 /* Cette instruction permet de continuer l'exécution du programme à un autre
 endroit, dans la même fonction. On l'utilise de la manière suivante : */
 goto label;
 /* Où label est un identificateur quelconque. Cet identificateur devra être défini
 quelque part dans la même fonction, avec la syntaxe suivante : */
 label:
 /* Ce label peut être mis à n'importe quel endroit dans la fonction, y compris avant
 ou après le goto, ou dans un autre bloc que là où sont utilisés la ou les
 instructions goto pointant vers ce label. Les labels doivent être uniques au sein
 d'une même fonction, mais on peut les réutiliser dans une autre fonction. */
 /* Un cas où l'emploi d'une instruction goto est tout à fait justifié, par exemple,
 est pour simuler le déclenchement d'une exception, pour sortir rapidement de
 plusieurs boucles imbriquées. */
 #if 0
 void boucle(void)
 while (1)
 struct Evenement_t * event;
 attend_evenement();
 while ((event = retire_evenement()))
 switch (event->type) {
 case FIN_TRAITEMENT:
 goto fin;
 fin:
 #endif
 /* Dans ce cas de figure, il serait possible d'utiliser aussi un booléen qui indique
 que le traitement est terminé, pour forcer la sortie des boucles. L'utilisation
 de goto dans cet exemple ne nuisant pas à la lisibilité du programme et étant
 tout aussi efficace, il est tout à fait légitime de l'utiliser.
 Il faut cependant noter que cette instruction est souvent considérée comme à
 éviter. */
 return 0;