Cours complet pour apprendre à programmer en D


précédentsommairesuivant

15. Boucle while (Tant que)

La boucle while est similaire à l'instruction if et fonctionne essentiellement comme une instruction if répétée. Tout comme if, while prend aussi une expression logique et évalue le bloc quand l'expression logique est vraie. La différence est que l'instruction while évalue l'expression et réexécute le bloc tant que l'expression est vraie, pas qu'une fois. Répéter un bloc de code de cette manière est appelé « boucler ».

Voici la syntaxe de l'instruction while :

 
Sélectionnez
while (une_expression_logique)
{
   // ... expression(s) à exécuter tant que c'est vrai
}

Par exemple, le code qui représente « manger des cookies tant qu'il y a un cookie » peut être codé comme ceci :

 
Sélectionnez
import std.stdio;
 
void main()
{
    bool ilyaUnCookie = true;
 
    while (ilyaUnCookie) {
      writeln("Prendre un cookie");
      writeln("Le manger");
    }
}

Ce programme continuera à répéter la boucle indéfiniment parce que la valeur de ilyaUnCookie n'est jamais changée et est toujours true.

while est utile quand la valeur d'une expression change pendant l'exécution du programme. Pour le voir, écrivons un programme qui demande un nombre à l'utilisateur tant que ce nombre est positif ou nul. Souvenez-vous que la valeur initiale de int est 0 :

 
Sélectionnez
import std.stdio;
 
void main()
{
    int nombre;
 
    while (nombre >= 0) {
      write("Veuillez entrer un nombre: ");
      readf(" %s", &nombre);
 
      writeln("Merci d'avoir entré ", nombre);
    }
 
    writeln("Sorti de la boucle");
}

Le programme remercie d'avoir donné un nombre et ne quitte la boucle que quand le nombre est strictement négatif.

15-1. L'instruction continue

Cette instruction commence directement l'itération suivante de la boucle, au lieu d'exécuter le reste des expressions du bloc.

Modifions le programme ci-dessus pour le compliquer un peu : au lieu de remercier pour n'importe quel nombre, n'acceptons pas 13. Le programme suivant ne remercie pas pour 13 parce que dans ce cas l'instruction continue fait que le programme retourne au début de la boucle et évalue à nouveau l'expression logique.

 
Sélectionnez
import std.stdio;
 
void main()
{
    int nombre;
 
    while (nombre >= 0) {
      write("Veuillez entrer un nombre: ");
      readf(" %s", &nombre);
 
      if (nombre == 13) {
            writeln("Désolé, nous ne pouvons pas accepter celui-là...");
            continue;
      }
 
      writeln("Merci d'avoir entré ", nombre);
    }
 
    writeln("Sorti de la boucle");
}

Nous pouvons définir le comportement de ce programme comme « prendre des nombres tant qu'ils sont supérieurs ou égaux à 0, mais ignorer 13 ».

15-2. L'instruction break

Parfois, il devient évident qu'il n'est plus nécessaire de rester dans la boucle. break permet au programme de sortir de la boucle directement. Le programme suivant sort de la boucle dès qu'il trouve un nombre spécial :

 
Sélectionnez
import std.stdio;
 
void main()
{
    int nombre;
 
    while (nombre >= 0) {
      write("Veuillez entrer un nombre : ");
      readf(" %s", &nombre);
 
      if (nombre == 42) {
         writeln("TROUVÉ !");
         break;
      }
 
      writeln("Merci d'avoir entré ", nombre);
    }
  
    writeln("Sorti de la boucle");
}

Nous pouvons résumer ce comportement comme : « Prendre des nombres tant qu'ils sont positifs ou nuls jusqu'à ce que le nombre soit 42 ».

15-3. Boucle infinie

Parfois, l'expression logique est intentionnellement la constante true. L'instruction break est une manière habituelle de sortir de telles boucles infinies.

Le programme suivant affiche un menu dans une boucle infinie ; le seul moyen de sortir de la boucle est l'instruction break :

 
Sélectionnez
import std.stdio;
 
void main()
{
    /* Boucle infinie, parce que l'expression logique est toujours vraie */
    while (true) {
      write("0:Quitter, 1:Turc, 2:Français - Votre choix ? ");
 
      int choix;
      readf(" %s", &choix);
 
      if (choix == 0) {
         writeln("À bientôt...");
         break;   // La seule sortie de cette boucle
 
      } else if (choix == 1) {
         writeln("Merhaba!");
 
      } else if (choix == 2) {
         writeln("Bonjour !");
 
      } else {
         writeln("Je ne connais pas ce choix... :/");
      }
    }
}

Les exceptions peuvent également terminer une boucle infinie. Nous aborderons les exceptions dans un chapitre suivant.

15-4. Exercices

  • Le programme suivant est conçu pour rester dans la boucle tant que l'entrée est 3, mais il y a un bogue : il ne demande jamais d'entrer quoi que ce soit :
 
Sélectionnez
import std.stdio;
 
void main()
{
    int nombre;
 
    while (nombre == 3) {
        write("Nombre ? ");
        readf(" %s", &nombre);
    }
}
  1. Corrigez le bogue. Le programme devrait rester dans la boucle tant que l'entrée est 3.
  2. Une fois que le programme obtient un nombre valide de la part d'Anna, il doit demander des nombres à Bill jusqu'à ce qu'il devine le nombre qu'Anna a donné.

Les nombres qu'Anna entre restent évidemment affichés à l'écran et peuvent être vus par Bill :o). Ignorons ce détail et écrivez le programme comme un exercice qui sert à mettre en pratique l'instruction while.

SolutionLa boucle while - Correction.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+