185 lines
6.2 KiB
Plaintext
185 lines
6.2 KiB
Plaintext
[set
|
||
title = "Boucle [c while] (Tant que)"
|
||
partAs = chapitre
|
||
translator = "Raphaël Jakse"
|
||
proofreader = "Stéphane Goujet"
|
||
]
|
||
|
||
La boucle [c while] est similaire à l'instruction [c if] et fonctionne essentiellement comme une instruction [c if] répétée. Tout comme [c if], [c while] prend aussi une expression logique et évalue le bloc quand l'expression logique est vraie. La différence est que l'instruction [c while] évalue l'expression et exécute le bloc encore, 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 [c while]~ :
|
||
|
||
[code=d <<<
|
||
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~ :
|
||
|
||
[code=d <<<
|
||
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 [c ilyaUnCookie] n'est jamais changée et est toujours [c true].
|
||
|
||
[c while] est utile quand la valeur d'une expression change pendant l'exécution du programme. Pour voir ceci, écrivons un programme qui demande un nombre à l'utilisateur tant que ce nombre est positif ou nul. Souvenez-vous que la valeur initiale de [c int] est 0~ :
|
||
|
||
[code=d <<<
|
||
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.
|
||
|
||
[ = L'instruction [c continue]
|
||
|
||
Cette instruction commence l'itération suivante de la boucle directement, 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 [c continue] fait que le programme va au début de la boucle et évalue à nouveau l'expression logique.
|
||
|
||
[code=d <<<
|
||
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~ ».
|
||
]
|
||
[ = L'instruction [c break]
|
||
Parfois, il devient évident qu'il n'y a plus besoin de rester dans la boucle. [c 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~ :
|
||
|
||
[code=d <<<
|
||
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'il sont positifs ou nuls jusqu'à ce que le nombre soit 42~ ».
|
||
]
|
||
[ = Boucle infinie
|
||
|
||
Parfois, l'expression logique est intentionnellement la constante [c true]. L'instruction [c break] est une manière commune 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 [c break]~ :
|
||
|
||
[code=d <<<
|
||
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... :/");
|
||
}
|
||
}
|
||
}
|
||
>>>]
|
||
|
||
[p Note~ : | les exceptions peuvent également terminer une boucle infinie. Nous verrons les exceptions dans un chapitre suivant. ]
|
||
]
|
||
|
||
[ = 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~ :
|
||
|
||
[code=d <<<
|
||
import std.stdio;
|
||
|
||
void main()
|
||
{
|
||
int nombre;
|
||
|
||
while (nombre == 3) {
|
||
write("Nombre ? ");
|
||
readf(" %s", &nombre);
|
||
}
|
||
}
|
||
>>>]
|
||
|
||
Corrigez le bogue. Le programme devrait rester dans la boucle tant que l'entrée est 3.
|
||
]
|
||
# [
|
||
Faire en sorte que l'ordinateur aide Anna et Bill à jouer à un jeu. D'abord, l'ordinateur demande un nombre à Anna entre 1 et 10. Le programme ne doit pas accepter d'autre nombre, il doit redemander jusqu'à ce qu'un nombre correct soit donné.
|
||
|
||
Une fois que le programme obtient un nombre valide de la part de Anna, il doit demander des nombres à Bill jusqu'à ce qu'il devine le nombre qu'Anna a donné.
|
||
|
||
[p Note~ : | 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 à pratiquer l'instruction [c while].]
|
||
]
|
||
|
||
[[part:corrections/while | … Les solutions]]
|
||
]
|