1

Les structures de
contrôle
Pré pa ré pa r J i mso n P ie rr e -L o u i s - E SIH
 2

Plan de la leçon
Les structures de contrôle
 Les structures conditionnelles
 Les structures sélectives
- if
- else
 Les structures répétitives
- for
- while
- do..while
 Branchement conditionnel
- switch
 Structure de rupture de séquence
- Continue
- Break
 3

Les instructions conditionnelles

 4

Introduction
Un programme informatique montre souvent qu’il est intelligent et même
super intelligent. Cet intelligence est due à quoi ?

La réponse est sans doute réside dans sa capacité à prendre des décisions
selon des conditions évaluées et pouvoir exécuter une ou plusieurs instructions
un nombre de fois donné.

Pour cela, le langage C++ dispose des instructions conditionnelles

Les instructions 5

conditionnelles (1)
Qu’est qu’une instruction conditionnelle ?

Il est parfois nécessaire que certaines parties du code ne s'exécutent que sous
certaines conditions ou qu’elles s'exécutent plusieurs fois dans une boucle , par
exemple, pour traiter tous les éléments d'un tableau.

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 les
structures de contrôle(instructions conditionnelles) classiques des langages de
programmation comme les tests, les boucles, les sauts, etc.
Les instructions 6

conditionnelles (2)
Qu’est qu’une instruction conditionnelle ?
Les instructions conditionnelles font appel toujours à des conditions qui
peuvent être:
Symbole Signification
== Est égal à
> Est supérieur à
< Est inférieur à
>= Est supérieur ou égal à
<= Est inférieur ou égal à
!= Est différent de
 7

Les structures
sélectives
 8

La structure sélective « if »

Cette structure de contrôle permet d'exécuter une instruction ou une suite
d'instructions seulement si une condition est évaluée et vraie.
Syntaxe
if (condition) instruction;
condition
Expression booléenne de la condition d'exécution.
instruction
Une instruction ou un bloc d'instructions exécuté si la condition est vraie
Note : Attention! Les parenthèses autour du texte sont nécessaires !
La structure sélective « if » 9

(1)
La condition qui se trouve entre les
deux parenthèses va être évaluée, si
elle est évaluée à vraie, les
instructions entre les deux accolades
{ } (instruction1, instruction2,….,
instruction n) vont être exécutées. Si
la condition n’est pas évaluée à vraie
aucune des instructions ne va être
exécutée

Les accolades { } ne sont pas obligatoires si on a une seule instruction à exécuter dans le cas où
la condition est vraie.
La structure sélective « if 10

»(2)
#include <iostream>
using namespace std;
int main()
{
int a;
cout << "Tapez la valeur de a : ";
cin >> a;
if (a %2==0)
cout << "a est une valeur paire" << endl;
cout << "Le programme est fini" << endl;
return 0;
}
La structure sélective « if » 11

(3)
Souvent en programmation lorsque des tests sont effectués deux cas sont possibles;
soit le test est vérifié à vrai ou à faux. Et des instructions sont à exécuter dans chacun
des cas possibles.
Donc, le else ajouté à if permet d’ exécuter des instructions dans le cas où le test n’est
pas évalué à vrai:
La structure sélective « if » 12

(4)
La structure de contrôle if peut être imbriquée, c’est-à-dire après qu’une
condition ait été évaluée à vraie, l’instruction à effectuer est encore une autre
condition.
syntaxe Exemple
int main()
if(condition1) { int a;
cout<<"Tapez la valeur de a : ";
if(condition2) cin>>a;
if (a>0)
if(condition3)
if(a%2==0)
if(a<=12)
cout << "a est OK et égale a:"<<a << endl;
}
 13

if…………… else
Les if et les else peuvent être imbriqués.
if (condition)
instructions;
else
if(condition)
instructions;
else
if(condition)
instructions;
Rappel: lorsqu’on a plusieurs conditions à vérifier on utilise les opérateurs: && et ||
Utilisation des opérateurs 14

&& et ||
Lorsqu’on a plusieurs conditions à vérifier on utilise les opérateurs: && et ||
if(condition1) && (condition2) && (condition3)
Instructions;
Ces conditions sont liées par des ET logiques, toutes doivent être évaluées à vraies pour que
l’instruction se réalise

if(condition1)||(condition2)||(condition3)
Instructions;
Ces conditions sont liées par des OU logiques, il suffit qu’une des conditions soit vraie pour que
l’instruction se réalise
 15

Les structures
répétitives
 16

Les structures répétitives

Les structures répétitives sont des instructions qui permettent l’exécution des
boucles d’instructions.

 Une boucle d’instruction représente une ou plusieurs instructions qui se

répètent.
 17

La boucle « for »(1)

La structure de contrôle for est sans doute l’une des plus importantes. Elle permet de réaliser
toutes sortes de boucles et, en particulier, les boucles itérant sur les valeurs d’une variable de
contrôle. La boucle for est effectuée tant que la condition est vérifiée. On connaît par avance le
nombre de fois où la boucle doit s'effectuer.
Sa syntaxe est la suivante :
for (initialisation ; test ; itération) opération ;
où initialisation : est une instruction (ou un bloc d’instructions) exécutée avant le premier
parcours de la boucle du for.
test : est une expression dont la valeur déterminera la fin de la boucle.
Itération : est l’opération à effectuer en fin de boucle.
opération : constitue le traitement de la boucle. Chacune de ses parties est facultative.
 18

La boucle « for » (2)

 19

La boucle « for » (3)

La séquence d’exécution est la suivante :
initialisation
test : saut en fin du for ou suite
opération
itération
retour au test
fin du for.
Exemple
somme = 0;
for (i=0; i<=10; i=i+1) somme = somme + i;
Note : 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,
 20

La boucle « for » (4)

Exemple
for (int i=0; i<10; ++i);
est strictement équivalent à :
{
int i;
for (i=0; i<10; ++i);
}
Cela signifie que l’on ne peut pas utiliser la variable i 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.
 21

La boucle « for » (5)

Note : Cette règle n’est pas celle utilisée par la plupart des compilateurs C++. La règle
qu’ils utilisent spécifie que la variable déclarée dans la partie initialisation de
l’instruction for reste déclarée après cette instruction. La différence est subtile, mais
importante. Cela pose assurément des problèmes de compatibilité avec les
programmes C++ écrits pour ces compilateurs, puisque dans un cas la variable doit
être ré-déclarée et dans l’autre cas elle ne le doit pas. Il est donc recommandé de ne
pas déclarer de variables dans la partie initialisation des instructions for pour assurer
une portabilité maximale.
 22

La boucle « while » (1)

Là où les instructions sont effectuées tant que la condition entre parenthèses reste
vérifiée( vraie). La condition est évaluée avant l'exécution des instructions. Tant que la
condition reste vraie une ou plusieurs instructions sont exécutées. Attention, il faut faire de
sorte que la condition devienne fausse, sinon vous aurez une boucle sans fin.
Sa syntaxe est la suivante :
while( expression) instruction;
ou
while( expression) {
instruction1;
....
instruction3;
}
L’ordre d’exécution est :
test
opération
 23

La boucle « while » (2)

Exemple
#include < iostream>
main()
{
somme = i = 0;
while (somme<1000)
{
somme = somme + 2 * i / (5 + i);
i = i + 1;
}
}
 24

La boucle « Do »(1)

La structure de contrôle do permet, tout comme le while, de réaliser des boucles en attente
d’une condition. Cependant, contrairement à celui-ci, le do 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 :
do instruction;

while ( condition);

..ou

do {

instruction1;

instruction2;

...

}while ( condition );
 25

La boucle « Do » (2)

L’opération est effectuée jusqu’à ce que Test ne soit plus vérifié.
L’ordre d’exécution est :
opération
Test

exemple1
#include <iostream>
main() {
int x=4, y=1;
do {
cout<<"x =" <<x <<" y =" <<y;
x++;
y--;
}while( x < y);
}
 26

La boucle « Do » (3)

exemple2
#include <iostream>
Using namespace std;
main()
{
int x=5, y=1;
// la boucle s'arrête lorsque x devient inférieur à y.
do {
cout<<"x =" <<x <<" y =" <<y;
x++;
y--;
}while( x < y);}
 27

La boucle « Do » (4)

Exemple
p = i = 1;
do
{
p = p * i;
i = i +1;
} while (i!=10);
 28

Branchement
conditionnel
Branchement conditionnel 29

(1)
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 de if successifs peut être relativement lourde. Le
C/C++ fournit donc la structure de contrôle switch, qui permet de réaliser un branchement
conditionnel. La valeur est évaluée en premier. Selon le résultat de l’évaluation, l’exécution
du programme se poursuit en 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.
Branchement conditionnel 30

(2)
Sa syntaxe est la suivante :
switch (valeur)
{
case cas1 :
instruction ;
break ;
case cas2 :
instruction ;
break ;
..
case casN :
instruction ;
break ;
default :
instruction ;
}
 31

Branchement conditionnel (3)

Exemple
i= 2;
switch (i) {
case 1:
case 2: /* Si i=1 ou 2, la ligne suivante sera exécutée. */
i=2-i;
break;
case 3:
i=0; /* Cette ligne ne sera jamais exécutée. */
default:
break; }
Note : Il est interdit d’effectuer une déclaration de variable dans un des case d’un switch.
 32

Rupture de
séquence
Les commandes de rupture 33

de séquence
Il existe différentes commandes dites commandes de rupture de séquence
(c’est-à-dire de changement de la suite des instructions à exécuter). Ces
commandes sont les suivantes :

- continue ;

- break ;

- return [valeur] ;
 34
Continue
L'instruction continue sert à "continuer" une boucle (for, while et do) avec la prochaine itération.

#include <iostream>

using namespace std;

main() {

for (int i = 0; i < 10; i++) {

if (i == 5) continue;

cout << "La variable i vaut: " << i << endl;

} Ce programme saute l'affichage de la sixième itération.

 Break 35

L'instruction break sert à "casser" ou interrompre une boucle (for, while et do), ou un switch.

#include <iostream>
using namespace std;
main(){
for (int i = 0; i < 10; i++)
{
cout << "La variable i vaut: " << i << endl;
if (i == 5)
break;
}
}Ce programme interrompt sa boucle lors de la sixième itération.