Structure répétitives
- Les Boucles -
Qu'est-ce qu'une boucle?
• Les boucles 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 parfois ces structures instructions répétitives ou bien
itérations.
• La façon la plus commune de faire une boucle est de créer un compteur
(une variable qui s'incrémente, c'est-à-dire qui augmente de 1 à chaque
tour de boucle) et de faire arrêter la boucle lorsque le compteur
dépasse une certaine valeur.
Qu'est-ce qu'une boucle?
On distingue 3 types de boucles courantes en C/C++ :
1. for
2. while
3. do. . . while
Itération
Le passage dans une boucle est appelé itération
La boucle For
• L'instruction for permet d'exécuter plusieurs fois la même série
d'instructions : c'est une boucle !
• Dans sa syntaxe, il suffit de préciser le nom de la variable qui sert de
compteur (et éventuellement sa valeur de départ, la condition sur la
variable pour laquelle la boucle s'arrête (bgénéralement une condition
qui teste si la valeur du compteur dépasse une limite) et enfin une
instruction qui incrémente (ou décrémente) le compteur.
La boucle For
Syntaxe Algo:
Pour <id_variable> allant de <val_inférieure> a <val_supérieure>
Faire <actions> ;
Finpour ;
Syntaxe C++:
for ( initialisation ; condition ; pas )
{
// Bloc d'instructions
}
Il y a trois instructions condensées, chacune séparée par un point-virgule.
- La première est l'initialisation : cette première instruction est utilisée pour préparer notre
variable compteur.
- La seconde est la condition : C’est la condition qui dit si la boucle doit être répétée ou non.
Tant que la condition est vraie, la boucle for continue.
- Enfin, il y a l'incrémentation : cette dernière instruction est exécutée à la fin de chaque tour
de boucle pour mettre à jour la variable compteur. Par exemple).
La boucle For
int cpt; Exemple:
for (cpt= initial ; cpt <= finale ;
int i;
cpt=cpt+pas)
for (i= 0 ; i <= 5 ; i=i+1)
{ {
cout << cpt << endl ; cout << i <<
} endl ;
}
Affichage ?
Attention !
• Il est fortement déconseillé de modifier la valeur du compteur (et/ou la valeur
de finale) à l'intérieur de la boucle. En effet, une telle action :
- Perturbe le nombre d'itérations prévu par la boucle
- Présente le risque d'aboutir à une boucle infinie
Exemple :
int compteur ;
for ( compteur = 0 ; compteur < 10 ; compteur ++)
{
cout << "La variable compteur vaut " << compteur << endl;
compteur = compteur +2;
}
La boucle while
• L'instruction while / Tantque représente un autre moyen d'exécuter plusieurs fois la
même série d'instructions.
• La syntaxe de cette expression est la suivante:
Tantque <Expression_booléenne>
instruction(s)
Fintantque ;
Syntaxe C++:
while ( Condition )
{
// Bloc d'instructions
}
La boucle while
• la condition (dite condition de contrôle de la boucle)
est évaluée avant chaque itération
• si la condition est vraie, on exécute le bloc d'instructions
(corps de la boucle), puis, on retourne tester la
condition. Si elle est encore vraie, on répète
l'exécution,...
• si la condition est fausse, on sort de la boucle et on
exécute l'instruction qui se trouve juste après l'accolade
fermante ‘}’ .
Exemple de boucle While
• On souhaite écrire un programme qui permet de contrôler la
saisie d'un entier positif.
Exemple :
int entierPositif = 0;
while ( entierPositif <=0)
{
cout <<" Tapez un entier positif ! ";
cin >> entierPositif ;
}
Répéter un certain nombre de fois
• On va pour cela créer une variable compteur qui vaudra 0 au début du programme
• Et que l'on va incrémenter à chaque itération.
• Exemple :
int compteur = 0;
while ( compteur < 10)
{
cout<< "La variable compteur vaut « << compteur );
compteur ++; // equivalent a compteur = compteur +1;
}
• Une incrémentation consiste à ajouter 1 à la variable en faisant
• var++;
Attention aux boucles infinies
• Le nombre d'itérations dans une boucle while n'est pas connu à l'avance. Il dépend de l'évaluation de la
condition.
• Lorsque vous créez une boucle, assurez-vous toujours qu'elle peut s'arrêter à un moment! Si la
condition est toujours vraie, votre programme ne s'arrêtera jamais !
• Exemple :
int compteur = 0;
while ( compteur >= 0)
{
cout<< "La variable compteur vaut « << compteur );
compteur ++; // équivalent a compteur = compteur +1;
}
• Une des instructions du corps de la boucle doit absolument changer la valeur de condition de vrai à faux
(après un certain nombre d'itérations), sinon le programme tourne indéfiniment
La boucle do...while
Syntaxe :
do Répéter
{ <actions simples> ;
// Bloc d'instructions Jusqu’à
} while ( Condition ); <condition> ;
• La boucle do...while est très similaire à while
• La seule chose qui change par rapport à while, c'est la position de la condition. Au
lieu d'être au début de la boucle, la condition est à la fin.
• Cette boucle s'exécutera donc toujours au moins une fois
La boucle do...while
Exemple :
int compteur = 0;
int somme = 0;
do
{
somme += compteur // équivalent a somme = somme + compteur
compteur ++;
} while ( compteur <= 10);
• Dans la boucle do...while , n'oubliez pas de mettre un point-virgule à la fin.
La boucle For Vs. La boucle While
• La boucle Pour est un cas particulier de la boucle
While (cas où le nombre d'itérations est connu et fixé)
• Tout ce qu'on peut écrire avec For peut être remplacé
par une boucle While (la réciproque n'est pas
forcément vraie).
La boucle For Vs. La boucle While
Exemple :
int compteur ;
for ( compteur = 0 ; compteur < 10 ; compteur ++)
{
cout<<"La variable compteur vaut" <<compteur;
}
// est equivalent a :
int compteur = 0;
while ( compteur < 10)
{
cout<<"La variable compteur vaut" <<compteur;
compteur ++;
}
Les boucles imbriqués
• Le bloc d'instructions d'une boucle peut contenir lui même une autre boucle. C'est ce qu'on
appelle des boucles imbriquées
Exemple :
int i;
int j=1;
for (i = 1 ; i <= 3 ; i++)
{
j=1
while (j <= 4)
{
cout <<"i=" <<i<<" j=" <<j;
j++;
}
}
Quelle boucle puisse-je utiliser pour mon
programme ?
Utilisez la structure qui reflète le mieux l'idée du programme que vous voulez réaliser :
• Si le bloc d'instructions ne doit pas être exécuté si la condition est fausse, alors
utilisez while ou for.
• Si le bloc d'instructions doit être exécuté au moins une fois, alors utilisez do while.
• Si le nombre d'exécutions du bloc d'instructions est connu à l'avance alors utilisez
for.
• Si le bloc d'instructions doit être exécuté aussi longtemps qu'une condition
extérieure est vraie alors utilisez while.
Le choix entre for et while n'est souvent qu'une question de préférence ou
d'habitudes.
Exemple avec while :
int N; /* nombre de donnees */ while (I <=N)
int NOMB ; /* nombre courant */ {
int I; /* compteur */ cout <<"nombre : ";
long SOM; /* la somme des nombres cin >> NOMB ;
entres */ SOM += NOMB ;
double PROD ; /* le produit des PROD *= NOMB ;
nombres entres */ I++;
cout <<" Nombre de donnees N : "; }
cin >> N; cout <<La somme des nombres
SOM =0; PROD =1; I=1; est" << SOM;
cout <<"Le produit des N
nombres est " << PROD ;
Exemple avec do...while :
int N; /* nombre de donnees */ do
int NOMB ; /* nombre courant */ {
int I; /* compteur */ cout <<"nombre : ";
long SOM; /* la somme des nombres cin >> NOMB ;
entres */ SOM += NOMB ;
double PROD ; /* le produit des nombres PROD += NOMB ;
entres */ I++;
cout <<" Nombre de donnees N : "; } while (I <=N);
cin >> N;
SOM =0; cout <<La somme des nombres
PROD =1; est" << SOM;
I=1; cout <<"Le produit des N nombres
est " << PROD ;
Exemple avec for :
int N; /* nombre de donnees */
for (I=1 ; I <=N ; I++)
int NOMB ; /* nombre courant */
{
int I; /* compteur */
cout <<"nombre : ";
long SOM; /* la somme des nombres
cin >> NOMB ;
entres */
SOM += NOMB ;
double PROD ; /* le produit des nombres
PROD *= NOMB ;
entres */
}
cout <<" Nombre de donnees N : ";
cout <<La somme des nombres
cin >> N;
est" << SOM;
cout <<"Le produit des N nombres est
SOM =0;
" << PROD ;
PROD =1;
