Le chapitre 3 du document aborde les structures de contrôle en C++, essentielles pour gérer l'exécution du programme selon des critères spécifiques. Il couvre les opérateurs de comparaison et logiques, ainsi que les structures conditionnelles comme 'if', 'else if', et 'switch', et les boucles 'for', 'while', et 'do...while'. Enfin, le chapitre présente des instructions comme 'break' et 'continue' pour gérer le flux d'exécution dans les boucles et les branchements.

1. Introduction au langage C++
Chapitre 3
Structures de contrôle
Youssouf EL ALLIOUI, youssouf.elallioui@uhp.ac.ma
Université Hassan Premier de Settat
Ce cours est disponible en format électronique sur http://fr.slideshare.net/yelallioui/
Objectif de ce chapitre
Nous allons aborder dans ce chapitre un autre aspect du langage indispensable à
la programmation, à savoir : les structures de contrôle. Ces structures permettent,
comme leur nom l’indique, de contrôler l’exécution du programme en fonction de
critères particulier.
Le C++ dispose de toutes structures de contrôle classiques des langages de
programmation comme les tests, les boucles, les sauts, etc. Dans ce chapitre, je vais
vous expliquer comment, dans un programme C++, on pourra :
 ne pas exécuter une partie des instructions, c’est à dire faire un saut
dans le programme,
 revenir en arrière, pour exécuter plusieurs fois de suite la même partie
d’un programme.
Entraînez-vous via
 Exercices applicatifs
 QCM fourni à la fin de la séance
 Les TPs
Sommaire
2016

2. 1 | 10
1 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
I. Opérateurs de comparaison___________________________________________2
II. Opérateurs logique__________________________________________________2
III. Structures de contrôle conditionnelles ________________________________2
III. 1. La structure conditionnelle if _____________________________________2
III. 2. Le branchement conditionnel switch ______________________________5
IV. Structures de contrôle itérative ______________________________________6
IV. 1. La boucle for________________________________________________6
IV. 2. La boucle while _____________________________________________7
IV. 3. La boucle do … while _______________________________________8
IV. 4. Le goto ____________________________________________________8
IV. 5. Le break ____________________________________________________8
IV. 6. Le continue __________________________________________________9
V. Ce que vous devez retenir ! ___________________________________________9
Références
Cours de C/C++ [Ouvrage] / aut. Casteyde Christian. - 2001. - Vol. Version 1.40.1 : p.
501.
Programmez avec le langage C++ [Ouvrage] / aut. Mathieu Nebra et Matthieu
Schaller. - [s.l.] : le Livre du Zéro, 2015.

3. 2 | 10
2 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
I. Opérateurs de comparaison
Pour commencer, il faut savoir que les conditions permettent de tester des variables. Pour
effectuer ces tests, nous utilisons des symboles. Voici le tableau des symboles à
connaître par cœur :
Symbole Signification
== Est égal à
> Est supérieur à
< Est inférieur à
>= Est supérieur ou égal à
<= Est inférieur ou égal à
!= Est différent de
Tableau 1 : Opérateurs de comparaison
Nous allons utiliser ces symboles pour effectuer des comparaisons dans nos conditions.
Faites très attention : il ne faut pas confondre l’opérateur d’égalité == (il y a bien 2
symboles « = ») et l’opérateur d’affectation = (un seul symbole « = ») vu dans le chapitre
précédent.
II. Opérateurs logique
Pour construire des conditions plus complexes, C++ nous permet de combiner plusieurs
tests au sein d'une seule et même condition dite complexe. Pour cela, il va falloir utiliser
de nouveaux symboles. Il s’agit des opérateurs logiques, Ce type d'opérateur permet de
vérifier si plusieurs conditions sont vraies.
Opérateur Dénomination Effet Syntaxe
|| OU logique
Vérifie qu'une des conditions est
réalisée
((condition1)||(condition2))
&& ET logique
Vérifie que toutes les conditions
sont réalisées
((condition1)&&(condition2))
! NON logique
Inverse l'état d'une variable
booléenne (retourne la valeur 1 si
la variable vaut 0, 0 si elle vaut 1)
(!condition)
Tableau 2 : Opérateurs logiques
III. Structures de contrôle conditionnelles
On appelle structures de contrôle conditionnelles les instructions qui permettent de
tester si une condition est vraie ou non. Il s'agit des instructions suivantes :
1) La structure conditionnelle if
2) Le branchement conditionnel switch
III. 1. La structure conditionnelle if

4. 3 | 10
3 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
4 utilisations de cette structure :
1) if : une première condition
2) if … else : ce qu'il faut faire si la condition n'est pas vérifiée,
3) else if : effectuer un autre test
4) L’opérateur ternaire : Une façon plus courte de faire un test
Laissez-moi vous expliquer chaque utilisation en détaille.
III. 1. 1. Une première condition if
La structure conditionnelle if permet de réaliser un test et d’exécuter une instruction
ou non selon le résultat de ce test. Sa syntaxe est la suivante :
1 if (condition) {
2 instruction ;
3 }
où condition est une expression dont la valeur est booléenne ou entière. Toute valeur
non nulle est considérée comme vraie. Si le test est vrai, instruction est exécutée.
NB :
- la condition doit être entre des parenthèses
- il est possible de définir plusieurs conditions à remplir avec les opérateurs ET et
OU (&& et ||). Par exemple, l'instruction ci-dessous exécutera les instructions si
l'une ou l'autre des deux conditions est vraie :
1 if ((condition1) || (condition2)) {
2 instruction ;
3 }
- s'il n'y a qu'une instruction, les accolades ne sont pas nécessaires...
III. 1. 2. if … else : ce qu'il faut faire si la condition n'est pas vérifiée
L'instruction if dans sa forme basique ne permet de tester qu'une condition, or la plupart
du temps on aimerait pouvoir choisir les instructions à exécuter en cas de non réalisation
de la condition. L'expression if ... else permet d'exécuter une autre série
d'instructions en cas de non-réalisation de la condition. Voici sa syntaxe :
1 if (condition) {
2 instruction ;
3 }
4 else {
5 autre instruction ;
6 }
III. 1. 3. else if : effectuer un autre test
Il est possible de faire plusieurs tests à la suite. Pour faire tous ces tests un à un dans
l'ordre, on va avoir recours à la condition else if qui signifie « sinon si ». Les tests vont
être lus dans l'ordre jusqu'à ce que l'un d'entre eux soit vérifié.
Voici un exemple : Imaginez qu'on souhaite faire le test suivant :

5. 4 | 10
4 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
- si le nombre d'enfants est égal à 0, afficher ce message "Eh bien alors, vous n'avez
pas d'enfant ?" ;
- sinon, si le nombre d'enfants est égal à 1, afficher ce message "Alors, c'est pour
quand le deuxieme ?";
- sinon, si le nombre d'enfants est égal à 2, afficher ce message "Quels beaux enfants
vous avez la !";
- sinon, afficher ce message "Bon, il faut arreter de faire des gosses maintenant !".
Bon, voici la solution :
1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int nbEnfants(2);
8
9 if (nbEnfants == 0)
10 {
11 cout << "Eh bien alors, vous n'avez pas d'enfant ?" << endl;
12 }
13 else if (nbEnfants == 1)
14 {
15 cout << "Alors, c'est pour quand le deuxieme ?" << endl;
16 }
17 else if (nbEnfants == 2)
18 {
19 cout << "Quels beaux enfants vous avez la !" << endl;
20 }
21 else
22 {
23 cout << "Bon, il faut arreter de faire des gosses maintenant !" <<
endl;
24 }
25
26 cout << "Fin du programme" << endl;
27 return 0;
28 }
Figure 1 : Exemple de l'instruction if ... else if ... else
Je vous laisse le soin de tester et comprendre vous-même cette solution.
III. 1. 4. Une façon plus courte de faire un test (opérateur ternaire)
Il est possible de faire un test avec une structure beaucoup moins lourde grâce à la
structure suivante, appelée opérateur ternaire :
1 (condition) ? instruction1 : instruction2
NB :
- la condition doit être entre des parenthèses
- Lorsque la condition est vraie, instruction1 est exécutée
- Lorsque la condition est fausse, instruction2 est exécutée

6. 5 | 10
5 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
III. 2. Le branchement conditionnel switch
Dans le cas où plusieurs instructions différentes doivent être exécutées selon la valeur
d’une variable de type intégral, l’écriture des if successifs peut être relativement lourde.
Le C++ fournit donc la structure de contrôle switch, qui permet de réaliser un
branchement conditionnel. Sa syntaxe est la suivante :
9 switch (variable)
10 {
11 case valeur1 :
12 instruction1;
13 break;
14
15 case valeur2 :
16 instruction2;
17 break;
18
19 case valeur3 :
20 instruction3;
21 break;
22
23 default:
24 instructionParDéfaut;
25 break;
26 }
valeur est évalué en premier. Son type doit être entier. Selon le résultat de
l’évaluation, l’exécution du programme se poursuit au cas de même valeur. Si aucun des cas
ne correspond et si default est présent, l’exécution se poursuit après default. Si en
revanche default n’est pas présent, on sort du switch.
Les instructions qui suivent le case approprié ou default sont exécutées. Puis, les
instructions du cas suivant sont également exécutées (on ne sort donc pas du switch).
Pour forcer la sortie du switch, on doit utiliser le mot-clé break.
Voici ce que donnerait le code précédent (Figure 1) avec switch :
1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 int nbEnfants(2);
8
9 switch (nbEnfants)
10 {
11 case 0:
12 cout << "Eh bien alors, vous n'avez pas d'enfant ?" << endl;
13 break;
14
15 case 1:
16 cout << "Alors, c'est pour quand le deuxieme ?" << endl;
17 break;
18
19 case 2:
20 cout << "Quels beaux enfants vous avez la !" << endl;
21 break;

7. 6 | 10
6 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
22
23 default:
24 cout << "Bon, il faut arreter de faire des gosses maintenant !"
<< endl;
25 break;
26 }
27
28 return 0;
29 }
Figure 2 : Exemple de l'instruction switch
IV. 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.
IV. 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(0);
8
9 for (compteur = 1 ; compteur < 10 ; compteur++)
10 {
11 cout << compteur << endl;
12 }
13

8. 7 | 10
7 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
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,
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.
IV. 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;

9. 8 | 10
8 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
11 i++;
12 }
13
14 return 0;
15 }
Je vous laisse le soin de tester et exécuter ce programme et s’assurer bien sûr qu’il donne
le même résultat.
IV. 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 }
... MEME résultat n’est-ce pas !
IV. 4. Le goto
Le goto est une structure de contrôle obsolète et ne doit plus être utilisé.
IV. 5. 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(0);

10. 9 | 10
9 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
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.
IV. 6. 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(0);
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.
V. Ce que vous devez retenir !
 Les conditions permettent de tester la valeur des variables et de modifier le
comportement du programme en conséquence.
 La condition de type if ... else if ... else est la plus courante.
 La condition switch, plus spécifique, permet de tester les différentes valeurs
possibles d'une seule variable.

11. 10 | 10
10 Introduction au langage C++ | Chapitre 3 : Structures de contrôle
 Les boucles permettent de répéter les mêmes instructions plusieurs fois.
 On distingue trois types de boucles : for, while et do... while.
 La boucle for est généralement utilisée lorsqu'on sait combien de fois on souhaite
répéter les instructions, tandis que while et do... while sont plutôt utilisées
lorsqu'on souhaite répéter des instructions jusqu'à ce qu'une condition
spécifique soit vérifiée.
 Le goto est une structure de contrôle obsolète et ne doit plus être utilisé.
 L'instruction break sert interrompre une boucle (for, while et do … while), ou
un switch.
 L'instruction continue sert à "continuer" une boucle (for, while et do … while)
avec la prochaine itération.