Les boucles "Tant que"

Introduction

Aujourd'hui, nous allons nous attaquer à un nouveau type de répétition, encore plus flexible. Imaginez que vous deviez écrire un algorithme qui demande à un utilisateur son mot de passe. Combien de tentatives lui faudra-t-il ? Une ? Trois ? Dix ? Nous ne pouvons pas le savoir à l'avance. Un autre exemple : simuler la chute de la population d'une espèce jusqu'à ce qu'elle atteigne un certain seuil. Le nombre d'années nécessaires est inconnu.

Pour ces situations où le nombre de répétitions dépend d'une condition qui doit être vérifiée à chaque tour, la boucle Pour n'est pas adaptée. Nous avons besoin d'une nouvelle structure : la boucle Tant que.

L'objectif de cette leçon est de vous apprendre à utiliser cette boucle pour exécuter un bloc d'instructions tant qu'une condition reste vraie. Maîtriser la boucle Tant que est crucial pour résoudre une immense catégorie de problèmes et constitue une étape majeure vers votre objectif de concevoir une logique algorithmique robuste.

1. Quand la boucle Pour ne suffit plus

Pour bien comprendre la nécessité de la boucle Tant que, commençons par un problème concret où le nombre de répétitions n'est pas fixé d'avance.

Comme vous l'avez constaté, le problème est de déterminer combien de jours seront nécessaires. Ce nombre n'est pas une donnée du problème, c'est le résultat que nous cherchons. Nous ne pouvons donc pas dire Pour i variant de 1 à ??? Faire....

Nous devons plutôt formuler notre logique différemment : "Tant que la masse de l'iceberg est supérieure à 1 kg, je continue de calculer la perte pour le jour suivant". C'est exactement ce que la boucle Tant que nous permet d'exprimer.

2. L'anatomie d'une boucle Tant que

La boucle Tant que est une structure de contrôle conditionnelle. Elle répète un bloc d'instructions aussi longtemps qu'une condition spécifiée est évaluée comme VRAI.

Syntaxe générale

En pseudo-code, la structure est très intuitive :

Tantque [condition] Faire
  // Bloc d'instructions à répéter
  Instruction 1
  Instruction 2
  ...
FinTantque

• Tantque ... FinTantque : Ces mots-clés délimitent la boucle.
• condition : Il s'agit d'une expression logique (comme masse > 1, mot_de_passe ≠ "secret", ou x <= 100) qui retourne VRAI ou FAUX.

Visualiser le mécanisme

Le déroulement d'une boucle Tant que est un cycle simple :

1. Vérifier la condition : L'algorithme évalue la condition.
2. Décider :
   • Si la condition est VRAI, le bloc d'instructions à l'intérieur de la boucle est exécuté. Une fois terminé, on retourne à l'étape 1.
   • Si la condition est FAUX, le bloc d'instructions est ignoré et le programme saute directement à l'instruction qui suit FinTantque.

L'organigramme suivant illustre parfaitement ce cycle :

Une conséquence importante de ce fonctionnement est que si la condition est fausse dès le départ, les instructions à l'intérieur de la boucle ne sont jamais exécutées.

3. Tracer l'exécution "à la main"

Comme pour la boucle Pour, le traçage manuel avec un tableau de suivi est la meilleure méthode pour comprendre et valider le comportement d'une boucle Tant que. Votre aisance avec cette technique pratique sera un grand atout.

Appliquons cette méthode à un exercice.

Cet exercice met en lumière un point essentiel : le tableau de suivi doit inclure non seulement les variables qui changent (u et n), mais aussi la condition elle-même. C'est en observant quand la condition passe de VRAI à FAUX que l'on comprend pourquoi la boucle s'arrête.

4. Le piège de la boucle infinie

Avec la boucle Tant que, nous rencontrons un nouveau risque qui n'existait pas avec la boucle Pour : la boucle infinie. C'est une boucle dont la condition ne devient jamais fausse, et qui s'exécute donc... éternellement.

Pour qu'une boucle Tant que puisse se terminer, il est impératif qu'au moins une des instructions à l'intérieur de la boucle puisse modifier la ou les variables impliquées dans la condition.

L'erreur de Paul est fondamentale : la condition dépend de n, mais la valeur de n ne change jamais à l'intérieur de la boucle. Si la boucle démarre, elle ne s'arrêtera donc jamais. La correction, qui consiste à ajouter n prend la valeur n + 1, est la clé pour assurer la terminaison de l'algorithme.

5. Application pratique : la validation des saisies

Un des usages les plus courants de la boucle Tant que est de forcer un utilisateur à saisir une donnée valide. Le principe est simple : "Tant que la donnée n'est pas correcte, redemande-la".

Cette structure est un patron (pattern) très fréquent :

1. Saisie initiale : On demande une première fois la donnée à l'utilisateur.
2. Boucle de validation : On entre dans une boucle Tant que qui vérifie si la donnée est invalide.
3. Correction : À l'intérieur de la boucle, on affiche un message d'erreur et on redemande la saisie.

La boucle ne s'arrêtera que lorsque l'utilisateur aura fourni une valeur qui rend la condition age < 0 fausse, c'est-à-dire un âge positif ou nul.

Conclusion

Aujourd'hui, vous avez ajouté la boucle Tant que à votre boîte à outils. Contrairement à la boucle Pour, elle n'est pas liée à un nombre de tours prédéfini mais à une condition, ce qui la rend extrêmement puissante et polyvalente.

Points clés à retenir :

• La boucle Tant que est utilisée pour répéter des instructions un nombre de fois inconnu, tant qu'une condition reste vraie.
• La condition est testée avant chaque tour. Si elle est fausse au départ, la boucle n'est jamais exécutée.
• La syntaxe est Tantque [condition] Faire ... FinTantque.
• Il est crucial que le corps de la boucle modifie une variable de la condition pour éviter une boucle infinie.
• Un cas d'usage très courant est la validation des saisies utilisateur.

Et après ?

Nous maîtrisons maintenant deux types de boucles : Pour pour les répétitions comptées et Tant que pour les répétitions conditionnelles. Dans la prochaine leçon, nous allons les comparer directement et établir des règles claires pour vous aider à choisir le type de boucle le plus approprié en fonction du problème à résoudre. Ce sera une étape clé pour affiner votre logique de conception d'algorithmes.