4 Les Instructions Répétitives

Les boucles permettent de faire exécuter plusieurs fois certaines phases de programme sans qu'il soit nécessaire à chaque fois de réécrire les instructions correspondantes. Le langage C dispose de trois structures répétitives et de 3 instructions spéciales :

while

La boucle while permet de faire répéter l'exécution d'instructions tant qu'une certaine condition est remplie (VRAI) .

Sa syntaxe est:

Construction sans bloc d'instructions:

while (condition) /* évaluation de la condition de bouclage */
instruction; /* si la condition est évaluée à VRAI, instruction est exécutée puis on réévalue condition */

ou

Construction avec bloc d'instructions:

while (condition) /* évaluation de la condition de bouclage */
{
instruction_1; /* si la condition est évaluée à VRAI, le bloc d'instructions est exécuté */
...
instruction_n; /* à la fin du bloc d'instructions, on réévalue condition */
}

Dès que la condition est évaluée à FAUX , on passe à la suite du programme, sans exécuter l'instruction du while (ou le bloc d'instructions).

Exemples:

#include<stdio.h> /* on a besoin de stdio.h pour la fonction "printf" */

main()
{ /* accolade de début de main */
     int x=5; /* déclaration de la variable */
    while(x<10) /* évaluation de la condition x inférieur à 10 */
           x++; /* incrémentation de x */
    printf("Ca y est : x est supérieur ou égal à 10\n"); /* instruction exécutée lorsqu'on sort de la boucle */
} /* accolade de fin du main */

#include<stdio.h> /* on a besoin de stdio.h pour la fonction "printf" */

main()
{ /* accolade de début de main */
     int x=5; /* déclaration de la variable */
    while(x<10) /* évaluation de la condition x inférieur à 10 */
        { /* accolade de début de bloc d'instructions du WHILE */
            printf("x est inférieur a 10\n"); /* tant que x est inférieur à 10, on exécute ce bloc d'instructions */
            x++; /* incrémentation de x */
        } /* accolade de fin de bloc d'instrucions du WHILE */
    printf("Ca y est : x est supérieur ou égal à 10\n"); /* instruction exécutée lorsqu'on sort de la boucle */
} /* accolade de fin du main */

Ce qui donne :

for

La structure for est une boucle qui teste une condition avant d'exécuter les instructions qui en dépendent. Ces instructions sont répétées un nombre paramétré de fois.

Sa syntaxe est :

Construction sans bloc d'instructions:

for (valeur_de_départ ; condition_d'arrêt ; modification_de_la_valeur_de_contrôle)
instruction;

ou

Construction avec bloc d'instructions:

for (valeur_de_départ ; condition_d'arrêt ; modification_de_la_valeur_de_contrôle)
{
instruction_1;
...
instruction_n;
}

Exemples:

#include<stdio.h> /* on en a besoin pour la fonction "printf" */

main()
{ /* accolade de début de main */
     int i; /* déclaration de la variable */
     printf("Je veux imprimer 5 fois coucou\n");
    for (i=0; i<5; i++) /* on part de i=0, et à chaque tour de boucle on ajoute 1, et on le compare à 5 */
          printf("coucou\n"); /* tant que i<5, on exécute l'instruction */
     printf("J\'ai fini : i=5\n"); /* quand i=5, on sort de la boucle, et ce message s'affiche */
} /* accolade de fin de main */

Ce qui donne :

#include<stdio.h> /* on en a besoin pour la fonction "printf" */

main()
{ /* accolade de début de main */
     int i; /* déclaration de la variable */
     printf("Je veux imprimer 5 fois coucou maman\n");
    for (i=0; i<5; i++) /* on part de i=0, et à chaque tour de boucle on ajoute 1, et on le compare à 5 */
         { /* accolade de début de bloc d'instructions FOR */
              printf("coucou "); /* tant que i<5, on exécute le bloc d'instructions */
              printf("maman\n");
         } /* accolade de fin de bloc d'instructions FOR */
     printf("J\'ai fini : i=5\n"); /* quand i=5, on sort de la boucle, et ce message s'affiche */
} /* accolade de fin de main */

Ce qui donne :

do ... while

Contrairement aux structures for et while, la boucle do while teste sa condition, après avoir exécuté une fois la/les instruction(s) qui en dépend(ent),.

Sa syntaxe est :

Construction sans bloc d'instructions:

do
instruction; /* cette instruction est exécutée une fois avant l'évaluation de la condition */
while (condition); /* tant que la condition est évaluée à VRAI, l'instruction est exécutée */

ou

Construction avec bloc d'instructions:

do
{
instruction_1; /* ce bloc d'instruction est exécuté une fois avant l'évaluation de la condition */
...
instruction_n;
}
while (condition); /* tant que la condition est évaluée à VRAI, le bloc d'instruction est exécuté */

Les boucles do while sont exécutées au moins une fois, même si la condition n'est jamais vérifiée.

Exemples:

#include<stdio.h> /* on a besoin de stdio.h pour la fonction "printf" */

main()
{ /* accolade de début de main */
     int x=5; /* déclaration de la variable */
     printf("x vaut 5 avant la boucle do while"); /* instruction exécutée avant la boucle */
    do
         x++; /* incrémentation de x */
    while(x<4); /* évaluation de la condition x inférieur à 4*/
     printf("x vaut 6, car l\'instruction a été exécutée avant le test de condition");/* instruction exécutée après la boucle */    /* si on avait eu un while, l'instruction n'aurait pas été exécutée car x n'est pas supérieur à 4 */
} /* accolade de fin du main */

#include<stdio.h> /* on a besoin de stdio.h pour la fonction "printf" */

main()
{ /* accolade de début de main */
     int x=5; /* déclaration de la variable */
     printf("x vaut 5 avant la boucle do... while\n"); /* instruction exécutée avant la boucle */
    do
         { /* accolade de début de bloc d'instructions du while*/
              printf("bonjour\n"); /* on exécute ce bloc d'instructions une fois puis tant que x est inférieur à 4\n*/
              x++; /* incrémentation de x */
         } /* accolade de fin de bloc d'instrucions du while*/
     while(x<4); /* évaluation de la condition x inférieur à 4*/
     printf("x vaut 6, car l\'instruction a été exécutée avant le test de condition\n");/* instruction exécutée après la boucle */    /* si on avait eu un while, l'instruction n'aurait pas été exécutée car x n'est pas supérieur à 4 */
} /* accolade de fin du main */

Ce qui donne :

break

Nous avons déjà vu le rôle de break au sein du bloc régi par une instruction switch. Le langage C autorise également l'emploi de cette instruction dans une boucle. Dans ce cas, elle sert à interrompre le déroulement de la boucle, en passant à l'instruction qui suit cette boucle. Bien entendu, cette instruction n'a d'intérêt que si son exécution est conditionnée par un choix; dans le cas contraire, elle serait exécutée dès le premier tour de boucle, ce qui rendrait la boucle inutile.

Exemple:

#include <stdio.h>

main()
{
    int i;
    for (i=1;i<=10;i++)
    {
         printf ("debut tour %d\n",i);
         printf ("action\n");
         if (i==3) break;
         printf ("fin tour %d\n",i);
    }
    printf ("apres la boucle");
}

Son exécution donne:

debut tour 1
action
fin tour 1
début tour 2
action
fin tour 2
debut tour 3
action
apres la boucle

continue

L'instruction continue, quant à elle, permet de passer "prématurément" au tour de boucle suivant, et donc de ne pas exécuter les instructions situées après, dans le tour où elle est exécutée.

Exemple:

#include <stdio.h>

main()
{
     int i;
     for (i=1;i<=5;i++)
    {
         printf ("debut tour %d\n",i);
         if (i<4) continue;
         printf ("bonjour\n");
    }
    printf ("apres la boucle");
}

Son exécution donne:

debut tour 1
debut tour 2
debut tour 3
debut tour 4
bonjour
debut tour 5
bonjour
apres la boucle

goto

Elle permet "classiquement" le branchement en un emplacement quelconque du programme. Voyez cet exemple qui simule, dans une boucle for, l'instruction break à l'aide de l'instruction goto.

Exemple:

#include <stdio.h>

main()
{
    int i;
    for (i=1;i<=10;i++)
   {
        printf ("debut tour %d\n",i);
        printf ("action\n");
        if (i==3) goto sortie;
        printf ("fin tour %d\n",i);
   }
   sortie: printf ("apres la boucle");
}

Son exécution donne:

debut tour 1
action fin tour 1
debut tour 2
action fin tour 2
debut tour 3
action
apres la boucle