Ce cours initie aux bases de la programmation en utilisant le langage C++ : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en C++)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Boucles conditionnelles
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en C++)
248 notes
À partir de la leçon
Structures de contrôle (2) : boucles et itérations
Cette semaine, nous terminons la présentation des « structures de contrôle » avec les boucles et les itérations qui permettent de faire répéter certaines parties d'un programme.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
Dans des séquences précédentes,
nous avons abordé la notion de structures de contrôle.
Nous avons vu qu'il s'agit d'instructions particulières qui vont permettre
de répéter des traitements ou d'exécuter des traitements en fonction d'un certain
nombre de conditions.
Nous allons aujourd'hui continuer sur cette lancée et aborder une autre façon
de répéter des traitements que l'on appelle les boucles conditionnelles.
Lorsque l'on souhaite dans un programme répéter un certain nombre de traitements
et que le nombre de répétitions est connu a priori, c'est-à-dire avant même d'entrer
dans la boucle, nous avons vu qu'il était possible d'avoir recours à une boucle for,
la notion d'itération.
Il existe cependant des situations où l'on souhaite répéter un traitement,
le répéter par exemple tant qu'une condition est vérifiée
mais on ne sait pas combien de fois il va être nécessaire de répéter les traitements
jusqu'à ce que la condition ne soit plus vérifiée.
Et dans ce cas, il faut avoir recours à d'autres types d'instructions de
répétition, les boucles conditionnelles, les boucles dont l'exécution
dépend de la réalisation d'une condition et plus concrètement en C++,
elles prendront la forme de boucles do while ou while.
Pour illustrer notre propos,
reprenons notre petit exemple de calcul des moyennes d'un certain nombre de notes.
Donc, nous ne savons pas a priori de combien de notes nous voulons calculer
la moyenne, donc nous commençons par le demander à l'utilisateur
et le nombre de notes voulu va être saisi via une interaction clavier.
Ensuite, si ce nombre de notes est positif,
nous allons utiliser une itération for pour saisir toutes les notes.
Donc à chaque itération, demander la note numéro i, saisir cette note via
une interaction clavier et incorporer la note à la somme de toutes les notes.
Donc une fois que nous avons atteint le nombre de notes voulu,
nous sortons évidemment de l'itération et nous continuons
l'exécution du programme en séquence et à ce moment-là,
nous allons calculer la moyenne des notes et la faire afficher.
Une observation que l'on peut faire ici est qu'il n'est pas très naturel qu'un
utilisateur saisisse un nombre de notes qui soit nul.
Et la question que l'on peut se poser,
c'est dans ce cas-là, comment forcer l'utilisateur à introduire
systématiquement un nombre de notes qui soit supérieur à zéro?
Très concrètement,
nous voulons ici répéter ces instructions jusqu'à ce que l'utilisateur
consente à introduire un nombre de notes qui soit strictement positif.
Nous ne savons pas ici combien de fois il faudrait répéter ces instructions
puisque nous ne pouvons pas prédire a priori quand l'utilisateur va
effectivement saisir un nombre de notes strictement positif.
Et donc dans ce cas, il faut avoir recours à une structure de contrôle particulière
et la réponse à nos besoins ici serait ce que l'on appelle la boucle do while.
La boucle do while se rédige concrètement comme suit.
On utilise le mot réservé, do, suivi d'une paire d'accolades
ouvrantes et fermantes et le mot réservé, while, pour dire, tant que,
et qui veut dire concrètement, répéter tant que cette condition est vraie.
Donc très concrètement,
nous allons répéter les instructions qui se trouvent dans ce que l'on appelle le
corps, donc toutes les instructions comprises entre les accolades.
Nous allons répéter l'exécution de ce corps tant que la condition est vraie.
Examinons maintenant pas à pas le déroulement de notre petit exemple
avec la boucle do while.
Nous présupposons ici qu'une variable nombre de notes a été au préalable
déclarée et est prête à contenir un nombre de notes saisi par un utilisateur.
Lorsque nous abordons cette instruction, rien ne nous empêche d'entrer dans le
corps de la boucle et à ce moment-là, nous allons signifier à l'utilisateur
que nous attendons de lui qu'il introduise un nombre de notes.
Le nombre de notes est saisi via une interaction clavier et nous aboutissons à
l'exécution de cette ligne qui va évaluer la condition de continuation de la boucle.
Supposons dans un premier temps que l'utilisateur saisisse en guise de nombre
de notes la valeur 0.
Donc, l'évaluation de cette condition dans ce cas-là va retourner true,
ce qui signifie que le nombre de notes ne répond pas aux attentes que nous avons et
nous allons donc entamer un nouveau cycle puisque la condition est vraie.
Nous allons donc à nouveau exécuter le corps de la boucle mais supposons que
cette fois-ci l'utilisateur introduise en guise de nombre de notes au moment de la
saisie clavier la valeur moins 1.
Au moment de l'évaluation de la condition de continuation,
cette condition va comme précédemment être évaluée à true
puisque moins 1 est bien évidemment inférieur ou égal à 0 et à ce moment-là,
nous allons à nouveau entamer une nouvelle itération de la boucle.
Nous entamons alors une troisième itération de la boucle.
A nouveau, nous allons demander à l'utilisateur d'entrer un nombre de notes,
lire cette note via une interaction clavier et supposons que cette fois-ci,
de guerre lasse, l'utilisateur finisse par comprendre ce qu'on attend de lui
et saisisse un nombre de notes qui soit strictement positif, par exemple 6.
A ce moment-là, au moment de l'évaluation de la condition de continuation
de la boucle, cette évaluation va retourner cette fois false
puisque 6 est supérieur strictement à 0 et à ce moment-là,
nous allons donc sortir de la boucle do while et continuer l'exécution après
le point-virgule terminant l'instruction do while.
Donc voici maintenant formellement les éléments de la syntaxe d'une instruction
do while en C++ : les mots réservés, do while, qui encadrent ce que l'on appelle
le corps de do while, lequel est entre accolades ouvrantes et fermantes.
Après le while se trouve la condition de continuation de la boucle
et la sémantique est la suivante : les traitements du corps sont répétés
tant que la condition est évaluée à true.
Donc, on répète les traitements tant que la condition est évaluée à true.
Alors, comme pour l'instruction de branchement conditionnel if,
la condition d'arrêt de la boucle do while peut être rédigée de façon
relativement complexe et avoir recours à des opérateurs logiques.
On peut par exemple écrire des conditions qui auraient cette allure : donc on itère
les traitements, on répète les traitements tant que x est égal à y plus z et
que z est supérieur à 10 ou que t est inférieur à 25 par exemple,
donc on peut imaginer la rédaction de conditions d'arrêt relativement
sophistiquées notamment en ayant recours à des connecteurs logiques,
à des opérateurs logiques.
Il faut noter également que les parenthèses autour de la condition sont
des éléments de syntaxe obligatoires en C++ et donc tout comme pour le if,
il va falloir rédiger notre condition entre une paire de parenthèses.
Une observation importante à faire à propos de la boucle do while est que son
corps va systématiquement être exécuté au moins une fois.
Effectivement, si on se rappelle l'exemple pas à pas d'exécution d'une
boucle do while, arrivés à ce stade de l'exécution, rien ne nous empêche de
rentrer à l'intérieur du corps et donc d'exécuter ce bloc au moins une fois.
Ce bloc d'instructions ne sera effectué qu'une seule fois si au bout
de la première itération,
l'évaluation de cette condition est telle que le résultat de l'évaluation est false.
A ce moment-là,
nous avons vu que nous allons poursuivre l'exécution après la boucle.
Mais entre temps, le bloc d'instructions ici aura été exécuté au moins une fois.
Donc, ceci est important et fait partie des caractéristiques de la
boucle do while.
Autre observation qui a son importance, si la condition ne devient jamais fausse,
eh bien, les traitements sont répétés indéfiniment.
Donc, il faut être attentif à bien formuler la condition d'arrêt de sorte à
ne pas tomber dans une boucle infinie, ce qui généralement n'est pas un comportement
que l'on va souhaiter, en tout cas à ce stade de votre apprentissage.
Voilà pour ce qui est des éléments fondamentaux concernant la boucle do while
Avant de clore sur le sujet de la syntaxe de l'instruction do while,
une dernière toute petite mise en garde syntaxique, le petit point-virgule
qu'on a tendance à oublier et qui clôt l'instruction do while.
Alors, il existe des situations où il est souhaitable de tester la
condition de la boucle avant même d'avoir exécuté le corps au moins une fois.
Et dans ce cas-là,
nous allons avoir recours à une variante de boucle conditionnelle qui est
l'instruction while qui se rédige comme suit : le mot réservé, while,
suivi directement de la condition entre toujours paire de parenthèses fermantes
ouvrantes et suivi du corps de la boucle entre accolades ouvrantes et fermantes.
Le principe de fonctionnement est le même,
est analogue à celui de la boucle do while.
Donc on va répéter les traitements tant que la condition est évaluée à true.
La différence principale avec la boucle do while est que
la condition est testée avant même d'entrer dans la boucle.
Donc, si l'on imagine que la première fois où on aborde cette instruction,
la condition ici est d'emblée fausse, on va directement passer à l'instruction
suivant le while et donc le bloc ne sera même pas exécuté une seule fois.
Ce qui est différent de l'instruction do while où ce bloc,
on vient de le voir, est exécuté au moins une fois toujours.
Voici maintenant deux petits exemples basiques permettant d'illustrer la
différence fondamentale entre un do while et un while.
Nous avons ici affaire à deux boucles très similaires dont les deux
conditions de continuation sont les mêmes.
Ces conditions de continuation vont dépendre dans les deux cas d'une
variable int i qui est initialisée à 100.
Commençons par examiner ce qui se passe lors de l'exécution du do while.
Lorsque nous atteignons l'exécution du do while, rien ne nous empêche d'entrer
directement dans le corps de la boucle et à ce moment-là,
nous allons afficher sur le terminal le message, bonjour.
Nous atteignons ensuite cette partie de la boucle do while
où il s'agit d'évaluer la condition de continuation.
Ici puisque i vaut 100, le résultat de l'évaluation sera bien évidemment false.
Ce qui veut dire que nous allons sortir de la boucle et continuer l'exécution avec
les éventuelles instructions suivant le do while.
Entre temps, le message, bonjour, aura été affiché sur le terminal.
Concernant la boucle while, Lorsque nous abordons l'exécution de cette ligne,
nous allons d'emblée évaluer la condition de continuation qui,
comme pour le cas précédent, puisque nous sommes exactement dans la même situation,
va être évaluée à false, ce qui veut dire que nous n'allons jamais entrer
dans le corps de la boucle et continuer à l'exécution directement après le while.
Donc dans ce cas-ci, la boucle n'affichera rien.
Donc, typiquement, nous sommes ici dans une situation où
deux boucles très similaires, un do while et while, ne font pas la même chose,
en raison du moment où la condition de continuation est évaluée.
Donc parmi les erreurs classiques lorsque l'on débute avec l'utilisation des boucles
while et do while, il en est une qui peut donner des résultats un peu déconcertants,
et qui est liée à notre fameux petit point-virgule.
Nous avons que ce point-virgule clôt l'instruction do while,
donc arrive après la condition du do while.
Si d'aventure on s'amusait à mettre un point-virgule après la condition d'un
while, on aurait un comportement inattendu et erroné de notre programme.
Donc voyons un petit peu ici concrètement ce qu'il se passerait si on mettait un
point-virgule.
Donc ici c'est interprété, cette instruction,
comme si nous avions une boucle while avec comme corps une instruction vide,
et donc, il n'y a rien à l'intérieur de cette boucle while dans le corps qui
permet de faire évoluer le i, donc si on imagine que ce i avait pour valeur quelque
chose d'inférieur à dix, donc par exemple un, cette boucle va cycler indéfiniment,
parce que, il n'y a aucun moyen de faire atteindre à i
une valeur qui lui permette de faire sortir de la boucle, donc de dépasser dix.
En réalité, ce ++i, que probablement on souhaitait mettre à l'intérieur du corps,
ne va jamais être atteint dans le cas de figure précis où i est inférieur à dix.
Donc ceci, cette instruction, va être considérée, cette instruction ++i,
va être considérée comme en dehors de la boucle while.
Vous connaissez désormais trois façons de répéter des instructions dans un programme
: la boucle fort, les itérations de type fort, que nous avons vu dans une séquence
précédente, et ce que nous venons de voir, les boucles conditionnelles qui peuvent
prendre la forme soit d'un while, soit d'un do while.
On va se poser la question maintenant de comment choisir entre l'une ou
l'autre des formes.
Le choix relève de principes assez simples.
Si le nombre de répétitions des traitements est connu d'avance, est
connu à priori, le choix va naturellement se porter vers une itération de type fort.
Imaginez par exemple que je souhaite calculer la moyenne de
tous les étudiants qui suivent ce cours, je connais, à priori,
le nombre d'étudiants suivant ce cours, et donc pour calculer la somme de leurs notes
et calculer la moyenne, je vais plutôt partir sur un choix de boucle fort,
puisque le nombre d'itérations est connu, a priori.
Sinon, si le nombre d'itérations n'est pas connu à priori, je vais orienter mon choix
vers l'utilisation d'une boucle conditionnelle de type while ou do while,
et à ce moment là comment faire le choix entre les deux, eh bien simplement,
on va distinguer entre le cas où l'on a besoin d'exécuter au moins une fois le
corps ou pas, donc dans les situations où j'ai besoin d'exécuter au moins une fois
le corps, ce qui par exemple est le cas lorsque j'interagis avec l'utilisateur.
Donc par exemple, je demande une valeur à l'utilisateur, je veux que cette valeur
soit comprise entre deux bornes, et j'ai besoin que l'utilisateur saisisse
au moins une fois la valeur avant de tester si elle satisfait la condition, et
à ce moment-là je vais plutôt orienter mon choix vers une boucle de type do while.
Sinon, eh bien le choix se portera naturellement sur une forme de type while,
donc une boucle où l'évaluation de la condition se fait avant même d'entrer
dans le corps de la boucle.
Alors étoffons un petit peu notre exemple de tout à l'heure.
Il s'agit d'un cas typique où nous avons besoin d'un do while parce que
l'utilisateur a besoin de saisir au moins une fois le nombre de notes
avant que l'on soit capable de tester si elle entre dans les bornes voulues,
donc nous avons recours à une boucle do while,
et maintenant nous nous proposons d'améliorer un petit peu ce programme,
de sorte à ce que l'utilisateur soit avisé au moment où il introduit, par exemple,
un nombre négatif, soit avisé des attentes du programme par le biais d'un message.
Donc on aimerait faire en sorte que le programme ci-dessus
soit complété de sorte à ce que l'utilisateur ait un message pertinent au
moment où il introduit une note qui est négative ou nulle.
Donc comment procéder?
Évidemment ce message devrait apparaître pour toutes les situations
où le nombre ne satisfait pas la condition souhaitée, donc c'est quelque chose qui,
vraisemblablement, va faire partie du corps de la boucle.
On doit répéter cette instruction à chaque fois que l'utilisateur
introduit quelque chose qui n'est pas valable.
Donc on peut imaginer une solution de cette nature, donc on enrichit le corps
de la boucle avec un test supplémentaire, donc après avoir fait la lecture.
On va tester si le nombre introduit est inférieur ou égal à zéro,
et à ce moment-là, afficher le message voulu pour aviser l'utilisateur.
Alors à noter que ceci fait effectivement partie du corps de la boucle, puisqu'on
veut répéter ce traitement à chaque fois qu'un nombre non souhaité est introduit.
iii montrer que dans cet exemple,
la condition qui consiste à évaluer si le nombre de notes est inférieur ou égal à
zéro apparaît désormais deux fois : une fois dans le if,
et une fois comme condition de continuation de la boucle do while.
Il aurait été judicieux ici, de stocker le résultat de l'évaluation de cette
condition, dans une variable, afin de ne pas répéter son évaluation.
Par exemple, je peux introduire une variable booléenne, saisie invalide,
que j'initialise à false, que je mets à jour ici, dans le corps de ma boucle,
à chaque itération, en y stockant le résultat de l'évaluation de la condition,
à savoir le nombre de notes, inférieur ou égal à zéro,
donc, dans saisie invalide je retrouve false, et à ce moment-là,
je peux écrire la condition de façon unifiée dans les deux cas,
en remplaçant ceux-ci simplement par
if (saisie_invalide) et je continue les traitement comme
je l'ai fait tout à l'heure, et pareil ici, je répète les traitement, while,
la valeur de la variable saisie_invalide.
Il s'agit là d'une bonne pratique, il est toujours souhaitable dans un programme
d'éviter les situations où on exprime deux fois de façon indépendante la même chose à
des endroits différents, c'est comme le copier-coller.
Alors toujours avec notre petit exemple de la saisie d'un nombre de notes
par l'utilisateur, examinons maintenant comment on peut formuler la condition de
façon différente pour répondre à d'autres besoins.
Jusqu'ici, nous imposions à l'utilisateur d'introduire un nombre de notes qui soit
supérieur à zéro.
Imaginons maintenant que l'on souhaite, en plus, limiter le nombre de notes à dix.
La question que l'on se pose est comment trouver, formuler, la nouvelle condition,
pour répondre à ce nouveau besoin.
Pour formuler correctement la condition d'arrêt,
commençons par l'exprimer tout simplement en langue naturelle.
Désormais, le nombre de notes introduit par l'utilisateur va être incorrect dans
deux situations : soit que l'utilisateur a introduit un nombre
inférieur ou égal à zéro, ce qui contredit ce souhait, soit l'utilisateur a introduit
un nombre supérieur à dix, ce qui contredit celui-ci.
Donc ici, on voit que, on doit boucler,
tant que l'on est dans l'une ou l'autre des situations, dans l'une ou l'autre des
situations on a un nombre incorrect, ce qui nous permet de voir assez
naturellement que l'on doit en fait avoir recours au connecteur ou, donc en fait
on continue les traitements tant que l'une ou l'autre des situations est rencontrée.
Ce qui, en C++, va se traduire par une ligne de code qui a cette allure,
on répète le traitement tant que le nombre de notes introduit est inférieur ou
égal à zéro, ou, que le nombre de notes est supérieur à dix.
Toujours dans le même esprit, imaginons que l'on souhaite écrire un petit
programme dont le but soit de faire deviner un nombre à un utilisateur.
Pour simplifier ici, on imagine que le nombre à deviner est toujours 5.
L'idée serait ici d'écrire une boucle do while,
qui demande un nombre à l'utilisateur, et qui le compare au nombre souhaité,
et on ne sort de la boucle que une fois le bon nombre trouvé.
Donc la question que nous nous posons c'est : comment formuler cette condition
ici pour sortir proprement de la boucle une fois que l'utilisateur a trouvé
le bon nombre?
Comme pour tout à l'heure,
on va formuler la condition en langue naturelle, on se dit que la boucle doit
être répétée tant que l'utilisateur n'a pas trouvé le nombre à deviner.
Ça veut dire quoi, concrètement?
Il n'a pas trouvé le nombre à deviner tant que le nombre qu'il a entré
est différent du nombre à deviner qui était 5.
Comment formuler cette condition en C++?
Tout simplement par la ligne suivante, donc on répète
le traitement tant que le nombre entré est différent du nombre à deviner.
Donc on voit que la formulation C++ est très voisine,
très proche, de la façon de le formuler en langue naturelle.
Sophistiquons maintenant un petit cet exemple où l'utilisateur doit
deviner un nombre, donc on imagine qu'on doit lui donner un nombre limité d'essais.
Il ne va pas pouvoir indéfiniment proposer une valeur.
Donc ici, on imagine qu'on va devoir avoir recours à un compteur d'essais,
donc une variable que l'on introduit ici, et que ce compteur d'essais va être
incrémenté à chaque itération de la boucle.
Et en fait on veut que, au bout de trois essais,
l'utilisateur ait perdu s'il n'a pas trouvé le nombre à deviner.
Donc la question que l'on se pose maintenant est : comment formuler
cette condition?
Encore une fois, commençons par formuler la condition en langue naturelle,
donc on se dit qu'on doit répéter la boucle tant que l'utilisateur
n'a pas trouvé le bon nombre, et qu'il lui reste des essais.
Donc ici c'est clair que les deux conditions doivent simultanément être
vérifiées, on doit avoir les deux conditions pour pourvoir continuer
à itérer dans la boucle.
Donc ici, on va essayer de le formuler d'une façon un petit peu plus proche du
C++, donc première condition, tant que le nombre entré est différent du nombre
à deviner, et deuxième condition, tant que le nombre d'essais est inférieur à trois,
les deux conditions devront être simultanément vérifiées.
En C++, cela va correspondre à la ligne de code suivante, donc première
condition ici, tant que le nombre entré est différent du nombre à deviner,
ce qui correspond exactement à ce qu'on a formulé ici,
et deuxième condition, tant que le nombre d'essais est inférieur à trois, ce qui
correspond à cette seconde condition, et nous avons ici notre opérateur logique et,
and, qui permet de, assurer que les deux conditions soient simultanément vérifiées.
Donc ici encore une fois, on voit que le formuler en C++ n'est
pas très loin de le formuler en langue naturelle.
L'utilisateur a désormais deux façons possibles de sortir de la boucle : il peut
en sortir soit parce qu'il a trouvé le nombre, ce qui veut dire que cette partie
de la condition devient fausse, ou alors parce qu'il a dépassé le nombre d'essais.
Et maintenant, supposons que nous souhaitions indiquer à l'utilisateur en
clair, pourquoi il est sorti concrètement de la boucle.
Alors si l'on veut informer l'utilisateur de pour quelles raisons il est sorti
exactement de la boucle, eh bien il suffit de complémenter le programme tel qu'il
était à l'origine, en faisant en sorte qu'une fois qu'on est sorti de la boucle,
on teste pour quelles conditions on est sorti.
Est-ce que l'on est sorti de la boucle en raison de l'échec de cette condition,
C'est-à-dire que l'utilisateur a deviné le nombre.
Ou est-ce qu'on est sorti de la boucle en raison de l'échec cette seconde condition,
est-ce que on est sorti de la boucle parce qu'on a dépassé le nombre d'essais?
Donc ici on va le tester tout simplement,
donc si le nombre entré est égal au nombre à deviner,
ce qui veut dire qu'on serait sorti en raison de l'échec de cette condition,
eh bien on peut signifier à l'utilisateur qu'il a trouvé le bon nombre.
Sinon, eh bien cela signifie qu'il a dépassé le nombre d'essais qui lui étaient
alloués, on peut donc l'informer qu'il a perdu et on peut aussi faire afficher,
de surcroît, le nombre à deviner,
de sorte à l'informer de ce que l'on s'attendait à ce qu'il trouve.
Alors attention ici aux erreurs de logique dans la formulation des tests.
Imaginons que, pour tester cette condition, j'ai effectivement
trouvé le bon nombre, je teste que je n'ai pas dépassé le nombre d'essais, eh bien je
vais passer à côté de la situation où l'utilisateur aurait deviné au troisième
essai exactement le bon nombre, et à ce moment-là on va comptabiliser ce cas comme
un cas d'échec au lieu de le comptabiliser proprement comme un cas de succès.
Donc il faut être bien vigilant à la logique de la formulation des tests
si l'on veut réaliser ce genre de traitement.
La bonne solution ici était celle qui a été montrée dans la première solution,
à savoir formuler la condition non pas par rapport au nombre d'essais mais
par rapport au fait d'avoir trouvé ou non le nombre, et cette façon de formuler la
condition va nous permettre d'éviter l'écueil que nous venons juste de décrire.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
