Les boucles

La structure de contrôle Pour

Une première manière de répéter plusieurs fois un ensemble d’instructions est de les positionner dans une boucle Pour. Cette boucle répète un certain nombre de fois les instructions qu’elle contient. Vous pouvez par exemple décider de répéter dix fois les mêmes instructions. Il est nécessaire que ce nombre de répétitions soit connu avant le début de la boucle. Si ce n’est pas le cas, il faudra utiliser une des autres boucles présentées dans ce chapitre.

Syntaxe :

Pour variable <- valeurInitiale à valeurFinale 
   instructions  
FPour 

Cette boucle est délimitée entre les mots-clé Pour et FPour (Fin de Pour). Elle utilise une variable qui lui permet de connaître le nombre d’itérations, c’est-à-dire de répétitions, déjà effectuées. Cette variable est initialisée à l’entrée dans la boucle avec une valeur initiale et elle est incrémentée à chaque fin d’itération. Lorsque la variable atteint la valeur finale, la boucle est terminée et le traitement se poursuit avec les instructions positionnées après la boucle.

Exemple :

Algo TableDeMultiplication  
# affiche la table de multiplication de 7  
Variable m : entier  
Constante TABLE : entier <- 7  
Début 
 écrire("Table de " & TABLE)  Pour m <- 0 à 10 
   écrire(m & " × " & TABLE & " = " & m×TABLE)  
 FPour  
Fin 

Cet algorithme affiche tout d’abord : Table de 7. Ensuite, la boucle commence. La variable m est initialisée à la valeur zéro. Une première itération est réalisée. L’unique instruction de la boucle affiche donc la valeur de la variable m, c’est-à-dire zéro, puis la chaîne de caractères " × " suivie de la valeur...

La structure de contrôle TantQue

Une deuxième manière de répéter des instructions est d’utiliser une boucle TantQue. Contrairement à la boucle Pour, il n’est pas nécessaire de connaître avant de commencer la boucle le nombre d’itérations qui seront effectuées. Le principe de cette boucle est d’être répétée tant que la condition indiquée par celle-ci est vraie. Dans la vie de tous les jours, cela peut se traduire, par exemple, par la situation suivante : "Tant que la balance affiche un poids inférieur à 400 g, je verse de la farine".

Syntaxe :

TantQue condition 
       Instructions  
FTq 

Cette boucle est délimitée par les mots-clés TantQue et FTq (Fin de TantQue). Comme le mot-clé TantQue le suggère, la condition indiquée à sa suite correspond à ce qui doit être vrai pour commencer une première itération ou pour recommencer avec une nouvelle itération. Autrement dit, tant que cette condition est vraie, on reste dans la boucle, et dès lors que cette condition devient fausse, la boucle se termine et l’exécution se poursuit avec les instructions situées après cette boucle.

La conséquence de cela est qu’il est possible de rester à tout jamais dans une boucle TantQue ; c’est ce qui se nomme une boucle infinie.

Exemple d’un code incorrect pouvant provoquer une boucle infinie :

Algo PeutNeJamaisTerminer  
# exemple de boucle infinie si la valeur saisie  
# n'est pas la bonne réponse  
Variable saisie : texte  
Début 
 saisie <- saisir("Quelle est la capitale de la France ?")  
       #Condition  
 TantQue saisie ≠ "Paris" 
   écrire("Vous vous êtes trompé !")  
 FTq 
 écrire("Bravo !")  
Fin 

Si la valeur saisie est différente de Paris, alors la condition saisie ≠ "Paris" est vraie et on rentre alors dans la boucle. Le message d’erreur...

La structure de contrôle Répéter

Cette troisième boucle est assez similaire à la boucle TantQue. L’unique différence (mais qui fait toute la différence !) est que la condition de cette boucle n’est pas testée initialement, mais seulement après chaque itération. De ce fait, les instructions contenues dans la boucle sont exécutées au moins une fois. De même que pour la boucle TantQue, tant que cette condition est vraie, une nouvelle itération sera effectuée. Dans la vie de tous les jours, cela pourrait par exemple être utilisé pour saisir son code de carte bleue : il faut au moins le saisir une fois, mais cette opération peut être répétée si le code saisi est erroné. La condition de la boucle n’est donc pas testée initialement, mais seulement après avoir effectué une première itération.

Syntaxe :

Répéter 
    (ré)affectation de la variable de la condition 
    instructions  
TantQue condition FRépéter 

La boucle est délimitée par les mots-clés Répéter et FRépéter. Tout comme avec une boucle TantQue, il est possible de faire une boucle infinie si la variable sur laquelle porte la condition n’est jamais modifiée au sein de la boucle. À la fin de la boucle, le mot-clé TantQue est utilisé pour indiquer que la boucle sera répétée tant que la condition qui suit est vraie.

Exemple :

Algo ConvertisseurEuroBitcoin  
Variable txConversion : réel  
Variable valeurEuro : réel  
Variable encore : texte  
Début 
 txConversion <- saisir("Combien d'euros vaut 1 bitcoin ?")  
 Répéter 
   valeurEuro <- saisir("Quelle somme en euros voulez-vous " & 
             ...

Le choix de la boucle la plus adaptée

Vous avez maintenant trois boucles à votre disposition pour écrire vos algorithmes. Une question légitime à se poser est de savoir dans quelles situations préférer l’une plutôt que l’autre. Pour répondre à cette question, je vous invite à vous poser deux questions :

Ces règles constituent des bonnes pratiques. Il est tout à fait possible de ne pas les respecter : par exemple, il est tout à fait possible de réaliser une boucle dont le nombre d’itérations est connu avant son début à l’aide d’une boucle TantQue ou d’une boucle Répéter ! Néanmoins, votre code sera moins facile à comprendre, donc plus difficile à maintenir et à optimiser.

En Java, il existe des mots-clés permettant de sortir de manière anticipée d’une boucle (break) ou de ne pas terminer...

Les boucles imbriquées

Dans le chapitre précédent, nous avons vu que les structures de contrôle peuvent être imbriquées les unes dans les autres. Ainsi, il est possible de mettre un Si dans une boucle. Il est également possible de nicher une boucle au sein d’une autre boucle.

Exemple d’algorithme avec une boucle imbriquée :

Algo TableDeMultiplication2  
Variable i, a, b, rep : entier  
Constante NB_QUESTIONS : entier <- 10  
Début  
 Pour i <- 1 à NB_QUESTIONS 
   a <- aléa(0, 10) 
   b <- aléa(0, 10) 
   rep <- saisir(a & " × " & b & " = ")  
   TantQue rep ≠ a*b 
     rep <- saisir("C'est faux ! Réessayez...")  
   FTq  
 FPour  
Fin 

Dans cet exemple, il y a une boucle Pour dans laquelle est nichée une boucle TantQue.

Dans un premier temps, oublions la boucle Pour et regardons le code qui est à l’intérieur. Une première interrogation sur une multiplication est posée à l’utilisateur. La boucle TantQue sert à vérifier la réponse de l’utilisateur. Si la réponse est bonne du premier coup, cette boucle sera sautée puisque la condition...

Exercices

Solutions des exercices

Algo MoyenneDesNotes  
# Saisit des valeurs et calcule la moyenne  
Variable nbVal, cpt : entier  
Variable moyenne, saisie : réel  
Début 
   moyenne <- 0 
   nbVal <- saisir("Entrer le nombre de notes : ")  
   Si nbVal ≤ 0 Alors 
         écrire("Le nombre de valeurs doit être strictement positif")  
   Sinon  
         Pour cpt <- 1 à nbVal 
                 saisie <- saisir("Note : ") 
                 moyenne <- moyenne + saisie / nbVal  
         FPour 
         écrire("La moyenne est " & moyenne)  
   FSi  
Fin 

Algo MoyenneDesNotesV2  
#Calcule la moyenne des notes saisies par l'utilisateur  
#L'utilisateur saisit -1 pour finir la saisie  
Variable nbVal : entier <- 0  
Variable saisie, total : réel  
Constante STOP : entier <- -1  
Début 
   total <- 0 
   saisie <- saisir ("Note (" & STOP & " pour terminer) ?")  
   TantQue saisie ≠ STOP  
         total <- total + saisie 
         nbVal <- nbVal + 1 
         saisie <- saisir ("Note (" & STOP & " pour terminer) ?")  
   FTq  
   Si nbVal ≠ 0 Alors 
         écrire("La moyenne des notes est de " & total/nbVal)  
   Sinon 
         écrire("Aucune note n'a été saisie")  
   FSi  
Fin 

Algo MoyenneDesNotesV3  
#Calcule la moyenne et donne le taux de notes ≥ 10  
Variable nbVal : entier <- 0  
Variable nbS : entier <- 0  
Variable saisie...