Structures de contrôle - itérations

Écrit le 11/11/2004 par Wikibooks
Dernière mise à jour : 02/02/2006

Boucle for

Syntaxe

for(initialisation ; condition ; instruction)
    bloc

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'instruction après chaque bloc.

On peut tout de suite remarquer que la boucle for du C est beaucoup plus puissante qu'une
boucle for classique, dans le sens où elle ne correspond pas forcément à un nombre
fini de tours de boucle.

Exemples

Exemple 1

for(i = 0 ; i < 10 ; i++)
{
    printf("%d\n", i);
}

Cet exemple est une boucle for normale, l'indice de boucle i est incrémenté à chaque tour et le bloc ne fait qu'afficher l'indice. Ce code affiche donc les 10 premiers entiers en partant de 0. Le bloc de code étant réduit à une instruction, on aurait pu écrire :

for(i = 0 ; i < 10 ; i++)
    printf("%d\n", i);

Exemple 2

i = 0;
for( ; i != 1 ; i = rand() % 4)
{
    printf("je continue\n");
}

Ce deuxième 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'instruction est réellement une instruction, on peut y faire appel à des fonctions ;
  3. le nombre d'itération n'est pas fixe, le programme affichera « je continue » un nombre (pseudo-)aléatoire de fois.

Boucle while

Syntaxe

while( condition )
    bloc

Une boucle while exécute le bloc d'instructions tant que la condition est vérifiée.

Exemple

i = 0
while( i < 10 )
{
    printf("%d\n", i);
    i = i + 1;
}

Cet exemple est le même que celui vu précédement pour la boucle for, il affiche les dix premiers entiers à partir de 0.

Boucle do-while

Syntaxe

do
    bloc
while( condition );

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).

Arrêt et continuation des boucles

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.

Saut inconditionnel (goto)

Beaucoup voient en cette instruction un blasphème de la programmation structurée, que seuls quelques esprits limités oseraient utiliser dans leur programme. Un élément de réponse face à l'aversion que provoque la vue de cette instruction, est qu'en cas d'abus le code est illisible, rappelant d'autres langages tristement célèbres pour avoir surexploité et imposé des constructions sibyllines à l'aide de goto (notamment en assembleur et en BASIC). Soit, si cette instruction existe, c'est qu'elle a son intérêt.

Cette instruction permet donc tout simplement 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;

label est un identificateur quelconque. Cet identificateur devra être définit 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 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.

while( 1 )
{
    struct Evenement_t * event;

    attend_evenement();

    while( (event = retire_evenement()) )
    {
       switch( event->type ) {
       case FIN_TRAITEMENT: goto fin;
       /* ... */
       }
    }
}
fin:
/* ... */

Dans ce cas de figure, il serait possible d'utiliser aussi un booléen, bien que ce genre de construction ne nuit absolument pas à la lisibilité du programme et est tout aussi efficace, sinon plus, pourquoi s'en priver ?

Attention toutefois au fait, et au risque de le répéter, qu'un usage abusif de cette instruction nuit grandement à la lisibilité d'un programme.

Cet article provient de Wikibooks et est sous licence GNU Free Documentation License. Il a été écrit par plusieurs personnes et est constamment mis à jour. Cet article est la version du 22 décembre 2004 à 01:21. L'article d'origine se trouve à http://fr.wikibooks.org/wiki/Programmation_C_Itérations.