CHAPITRE IV

Structures de contrôle répétitives en langage C :

Les boucles

I. Introduction
On appelle structures conditionnelles, les instructions qui permettent de tester si une
condition est vraie ou bien fausse (voir chapitre 3). Celles-ci peuvent être associées à d’autres
structures qui se répètent plusieurs fois de suite suivant la réalisation d’une certaine condition
appelée test d’arrêt: Ces structures sont appelées des boucles.

II. Généralités sur les boucles

Qu'est-ce qu'une boucle ?
En programmation, c'est une technique permettant d'exécuter plusieurs fois la même série
d'instructions selon une certaine condition.

Tout comme pour les structures de contrôle sélectives, les boucles peuvent être réalisées de
différentes manières. En langage C, on distingue 3 types de boucles courantes:
 while
 do... while
 for

Remarque :
- Chaque exécution du corps d'une boucle s'appelle une itération.
- Chacune de ces boucles a ses avantages et ses inconvénients.

Les 3 types de boucles font la même chose c’est répéter les mêmes instructions un certain nombre
de fois (avec bien sûr des différences entre ces 3 types qu’on va voir plus loin).
Dans tous les cas, le schéma général des boucles est le suivant :

Instruction 1
Instruction 2
Revenir au point de départ Exécuter les instructions
Instruction 3
Instruction 4

Ce schéma fonctionne de la manière suivante :

1. La définition des valeurs initiales et le test d’arrêt (condition qui permet de poursuivre ou
bien d’arrêter la boucle suivant qu’elle est vérifiée ou non).
2. Généralement, l'ordinateur exécute le bloc d’instructions (corps de la boucle) d’une
manière séquentielle (de haut en bas);
3. Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction autant de fois
qu’il le faudra jusqu’à ce que le test d’arrêt soit vérifié.

De cette manière, l'ordinateur est capable de répéter ces instructions à l'infini si on ne l'arrête pas,
et c'est là qu'on retrouve les conditions. Quand on crée une boucle, on indique toujours une
condition. Cette condition c’est elle qui permet de répéter ou d’arrêter la boucle selon si la
condition est vraie ou fausse.

1
III. différent type de boucle
En langage C, on distingue 3 types de boucles:
 while
 do... while
 for

III.1 La boucle while

La boucle « while » (qui signifie « Tant que » en français) permet de répéter l'exécution
d’un bloc d’instruction tant que sa condition est vraie. La syntaxe générale de cette boucle s’écrit
comme suit :
while (condition)
{
Instruction 1
Instruction 2
Instruction 3
}

III.1.1 Fonctionnement de la boucle "while":

Lorsque l'instruction ‘’while’’ est rencontrée, la condition entre parenthèses est testée.
- Si elle est vraie alors l'instruction (ou le bloc d'instructions) après le while est éxécuté(e) et
la condition est testée à nouveau.
- S’elle reste vraie le cycle sera répété à nouveau jusqu'à ce que la condition devienne
fausse; l'exécution continue alors directement à la première instruction après le while.

Remarque : Le test de la condition est effectué avant chaque exécution du contenu de la boucle.
Exemple
#include <stdio.h>
#include<conio.h> Initialisation de i
main()
{
int i = 1 ;
while (i<5)
{
printf(" L'execusion n %d de la boucle \n", i) ;
i++;
}
getch(); Incrémentation de i
}
L’exécution de l’exemple ci-dessus donne la fenêtre suivante :

2
Commentaires: L’exécution de ce programme montre que la boucle à été exécutée 4 fois (i=1, 2,
3 et 4). La condition qui permet à la boucle de s’exécuter est tant que i< 5. Le compteur i est
initialisé par la valeur entière 1. Pour exécuter le contenu de la boucle, on test tout d’abord si sa
condition est vérifiée ( si la variable i est < 5 ). Après chaque exécution de la boucle, le compteur i
est incrémenté de 1.

III.2 La boucle "do…while"

En algorithmique, la boucle "Répéter…jusqu’à" a été traitée en détails. Cette boucle qui
devient "do…while" en langage C, peut être traduite en "Répéter(ou faire)…tant que". C’est
une boucle tant que dont la condition est évaluée à la fin.
La syntaxe de cette boucle s’écrit :
do {
Instruction1 ;
Instruction2 ;
Instruction3 ;
……………. ;
} while ( condition ) ;
Le bloc d’instruction est exécuté tant que la condition est vraie.
III.2.1 Fonctionnement de la boucle "do…while" :
Le fonctionnement de cette boucle est analogue à celui de la boucle "while" à quelques
détails prés. Le programme exécute tout d’abord les instructions avant même de tester la
condition. Une boucle "do…while" est donc exécutée au moins une fois. Le programme ne peut
reprendre l’exécution du bloc d’instructions que si la condition est vérifiée.
Exemple : Nous reprenons l’exemple précédent.
#include <stdio.h>
#include<conio.h>
main()
{
int i = 1 ;
do
{
printf(" L'execusion n %d de la boucle \n", i) ;
i++;
} while (i<5);
getch();
}

3
 De la même façon que pour la boucle "while", le compteur est initialisé avant le premier
passage dans la boucle. L’exécution de l’exemple ci-dessus donne les résultats de la fenêtre
suivante :

III.2.2 Comparaison entre les boucles "while" et "do…while"

Boucle "while" Boucle "do…while"

Condition Fausse

Vraie Traitement

Traitement Vraie Condition

Fausse
La suite

 Une première différence entre les boucles "while" et "do…while" réside dans
l’emplacement de la condition à tester. Contrairement à la seconde boucle (do…while), la
condition est examinée avant l’exécution du bloc d’instructions pour la première boucle
(while).
 Si la condition n’est pas vérifiée, le bloc d’instructions est exécuté une fois pour la boucle
"do…while" alors qu’il ne sera jamais exécuté pour la boucle "while".

4
Exemple:

Boucle while Boucle do while

#include <stdio.h> #include <stdio.h>
#include<conio.h> #include<conio.h>
main() main()
{ {
int i = 6 ; int i = 6 ;
while (i<5) do
{ {
printf(" L'execusion n %d de la boucle \n", i) ; printf(" L'exécution n %d de la boucle \n", i) ;
i++; i++;
} }while (i<5);
getch(); getch();
} }

Commentaires : Dans cet exemple, la variable i a été initialisée par la valeur entière 6. Dans ce
cas, la condition (i<5) n’est pas réalisée et pourtant la boucle "do…while" a été exécutée une fois.
Quant à la boucle "while", elle n’a pas été exécutée.

III.3 La boucle "for"

Le troisième type de boucle est celui qui est réalisé par le mot clé "for". Cette boucle est
fréquemment utilisée en programmation lorsque le nombre d’itérations à effectuer est connu
d’avance. Cela est certainement très utile lorsqu’il s’agit d’un traitement des tableaux, des
séquences d’éléments etc…

La syntaxe de la boucle "for" est la suivante :

for (initialisation; condition; pas)

{
Bloc d’instructions
}

III.3.1 Fonctionnement de la boucle "for" (figure.1):

Le fonctionnement de la boucle "for" est conditionné par trois entités de contrôle (initialisation,
condition; pas) :
 initialisation : Lorsque l’instruction "for" est rencontrée pour la première fois dans un
programme, la partie initialisation est exécutée en premier. Celle-ci permet en effet de
donner au compteur une valeur initiale.

5
  condition : Après l’initialisation, la condition est testée (test sur le compteur). Si elle est
vérifiée (la valeur du compteur est inférieure à celle du nombre d’itérations maximal), le
bloc d’instructions est exécuté, sinon le programme passe à l'instruction qui suit
immédiatement "for". Autrement dit, le bloc d’instructions est exécuté tant que la
condition est vérifiée.
 pas: C’est le pas d’avancement du compteur qui peut être soit une incrémentation ou bien
une décrémentation du compteur.
Remarque: L’initialisation ne s'effectue qu'une seule et unique fois durant tout le passage par la
boucle for et cela tout au début de cette boucle.

Figure.1:organigramme représentant le fonctionnement de la boucle for

Exemple:
#include <stdio.h>
#include<conio.h>
main()
{
int i;
for(i=1; i<5; i++)
printf(" L'execution n %d de la boucle \n", i) ;
getch();
}
L’exécution du programme de l’exemple ci-dessus donne les résultats de la fenêtre suivante :