Chapitre 3: Structures de contrôle itérative
Les structures de contrôle itératives sont des structures qui permettent d'exécuter
plusieurs fois la même série d'instructions jusqu'à ce qu'une condition ne soit plus
réalisée. On appelle ces structures des boucles.
Il existe 3 types de boucles à connaître :
1) la boucle for,
2) la boucle while et
3) la boucle do … while.
1. La boucle for
La structure de contrôle for est sans doute l’une des plus importantes. Elle permet de
condenser :
- Un compteur : une instruction (ou un bloc d’instructions) exécutée avant le premier
parcours de la boucle du for. Il consiste à préciser le nom de la variable qui sert de
compteur et éventuellement sa valeur de départ.
- une condition : une expression dont la valeur déterminera la fin de la boucle.
- une itération : une instruction qui incrémente ou décrémente le compteur.
Sa syntaxe est la suivante :
1 for (compteur; condition; itération) {
2 instructions ;
3 }
instruction constitue le traitement de la boucle.
Regardons un exemple concret qui affiche des nombres de 1 à 9 :
1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int compteur;
8
9 for (compteur = 1 ; compteur < 10 ; compteur++)
10 {
11 cout << compteur << endl;
12 }
13
14 return 0;
15 }
Cette boucle affiche 10 fois la valeur de compteur, c'est-à-dire 1, 2, …, 9.
Elle commence à compteur = 1, vérifie que compteur est bien inférieur à 10, etc.
jusqu'à atteindre la valeur compteur = 10, pour laquelle la condition ne sera plus
réalisée, la boucle s'interrompra et le programme continuera son cours.
NB : En C++, il est possible que la partie initialisation déclare une variable. Dans ce cas,
la variable déclarée n’est définie qu’à l’intérieur de l’instruction for. Par exemple :
9 for (int compteur = 1 ; compteur < 10 ; compteur++)
10 {
11 cout << compteur << endl;
12 }
Cela signifie que l’on ne peut pas utiliser la variable compteur après l’instruction for,
1
puisqu’elle n’est définie que dans le corps de cette instruction. Cela permet de réaliser
des variables muettes qui ne servent qu’à l’instruction for dans laquelle elles sont
définies.
2. La boucle while
Le while permet d’exécuter des instructions en boucle tant qu’une condition est vraie.
Sa syntaxe est la suivante :
1 while (condition) {
2 instructions ;
3 }
Tout ce qui est entre accolades sera répété tant que la condition est vérifiée. Essayons
de refaire l’exemple précédent, qui affiche les nombre de 1 à 9, en utilisant cette fois-
ci la boucle while :
1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 int i = 1;
7
8 while (i < 10)
9 {
10 cout << i << endl;
11 i++;
12 }
13
14 return 0;
15 }
3. La boucle do … while
La structure de contrôle do … while permet, tout comme le while, de réaliser des
boucles en attente d’une condition. Cependant, contrairement à celui-ci, le do … while
effectue le test sur la condition après l’exécution des instructions. Cela signifie que les
instructions sont toujours exécutées au moins une fois, que le test soit vérifié ou non. Sa
syntaxe est la suivante :
1 do
2 {
3 instructions ;
4 } while (condition) ;
Voici le même exemple en do ... while :
1 #include <iostream>
2 using namespace std;
3
4 int main()
5 {
6 int i = 1;
7
8 do
9 {
10 cout << i << endl;
11 i++;
12 } while(i<10);
13
14 return 0;
15 }
2
4. Le break
L'instruction break sert à "casser" ou interrompre une boucle (for, while et do …
while), ou un switch.
1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int i;
8
9 for (i = 1 ; i < 10 ; i++)
10 {
11 cout << i << endl;
12
13 if (i==5)
14 break;
15 }
16
17 return 0;
18 }
Ce programme interrompt sa boucle lors de la 6ème itération et n’affiche que les nombres
de 1 jusqu’à 5.
5. Le continue
L'instruction continue sert à "continuer" une boucle (for, while et do … while) avec
la prochaine itération. Voir l’exemple suivant :
1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int i;
8
9 for (i = 1 ; i < 10 ; i++)
10 {
11 if (i == 5) continue;
12 cout << i << endl;
13 }
14
15 return 0;
16 }
Ce programme saute l'affichage de la sixième itération, c’est-à-dire le cas où i=5.
