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

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.

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

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 :

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

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;

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

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;

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

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.

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.