Vous vous apprêtez à lire un tutoriel rédigé par un membre de ce site. Malgré tout le soin que ce membre a pu apporter au tutoriel, nous ne pouvons pas garantir que les informations contenues sur cette page sont exactes à 100%. Merci de garder cela en tête lorsque vous lirez cette page ;o)
Tout comme pour les conditions, il y a plusieurs façons de réaliser des boucles :
- while ... do
- repeat ... until
- For ... : = ... To ... Do ... (et son alternative : For ... : = ... DownTo ... Do ...)
Le schéma est, quand même, toujours identique :
Euh, oui, c'est pas moi qui l'ai fait, je l'ai honteusement piqué à M@teo...Mais que se passe-t-il ?
L'ordinateur lit, dans l'ordre, les instructions
(la flèche rouge).
A la fin, il repart au début
(la flèche verte).
Et ainsi de suite...
(les deux flèches).
Mais là, on rencontre un problème, et un gros ! Car la boucle, telle qu'elle est là, elle va jamais s'arrêter, l'ordinateur restera infatigable !
Heureusement, il y a une solution à ça.
Et c'est là qu'on aura besoin ...
des conditions (si votre réaction en lisant ça, est :
"Hein ? De quoi il parle, lui ?" allez tout de suite relire le chapitre sur les conditions).
Quand on crée une boucle, on indique toujours une condition. Cette condition signifiera : "Répète la boucle tant que cette condition est vraie". Donc, pour faire intervenir les booléens :
"Répète la boucle tant que ça renvoie TRUE".
Mais je sens que vous n'en pouvez plus, et que vous voulez découvrir le premier type de boucle ! Alors passons sans tarder à la prochaine partie !
Voilà comment se construit une boucle
"while ... do ..." (abréviation :
while) :
Code : Pascal1
2
3
4
5 | while { Condition } do
begin
{ Instructions à répéter }
end ;
|
C'est aussi simple que ça.
While signifie "Tant que", et
do signifie "Fait". On dit donc à l'ordinateur : "Tant que ça renvoie
TRUE, fais les instructions".
Je vous propose de faire un test simple : on va demander à l'utilisateur de taper le code secret. Tant qu'il n'a pas tapé le bon, on recommence à le lui demander. Le programme ne pourra s'arrêter que si l'utilisateur tape le bon code secret (il a intérêt à le rentrer s'il veut pas y passer sa journée !) :
Code : Pascal1
2
3
4
5
6
7
8
9 | var code:string;
begin
while code <> 'Jambon' { c'est le seul truc qui m'est passé par la tête } do
begin
write('Tapez le code secret : ');
readln(code);
end;
end.
|
Voici maintenant le test que j'ai fait. Notez que j'ai fait exprès de me planter 2-3 fois avant de taper le bon code, pour jouer au voleur.
Code : Console | Tapez le code secret : Fromage
Tapez le code secret : Pain au chocolat
Tapez le code secret : Salade
Tapez le code secret : Mayonnaise
Tapez le code secret : Jambon |
Notez que j'avais un peu faim à ce moment là...
Le programme s'est arrêté après avoir tapé le code 'Jambon'.
Cette boucle
while se répète donc tant que l'utilisateur n'a pas tapé 'Jambon', c'est assez simple.
Maintenant, essayons de faire quelque chose d'un peu plus intéressant : on veut que notre boucle se répète un certain nombre de fois.
On va pour cela créer une variable "compteur", qui vaudra 0 au début du programme, et que l'on va incrémenter au fur et à mesure. Vous vous souvenez de l'incrémentation ? Ça consiste à ajouter 1 à la variable en faisant
inc(variable, 1);.
Regardez attentivement ce bout de code et, surtout, essayez de le comprendre :
Code : Pascal 1
2
3
4
5
6
7
8
9
10 | var compteur:integer;
begin
compteur := 0;
while compteur < 10 do
begin
writeln('Ceci va se répèter 10 fois.');
inc(compteur, 1);
end;
end.
|
Résultat :
Code : Console | Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois.
Ceci va se répèter 10 fois. |
Ce code répète 10 fois l'affichage de "Ceci va se répéter 10 fois.".
Comment ça marche ?
Au départ, on a une variable
compteur initialisée à 0. Elle vaut donc 0 au début du programme.
La boucle
while ordonne la répétition
TANT QUE compteur est inférieur à 10. Comme compteur vaut 0 au départ, on rentre dans la boucle.
On affiche la phrase : "Ceci va se répéter 10 fois." via un
writeln.
On incrémente la valeur de la variable
compteur, grâce à l'instruction "
inc(compteur, 1);".
compteur valait 0, elle vaut maintenant 1.
On arrive à la fin de la boucle (
end;) : on repart donc au début, au niveau du
while. On refait le test du
while :
"Est-ce que compteur est toujours inférieur à 10 ?". Ben oui,
compteur vaut 1
. Donc on recommence les instructions de la boucle.
Et ainsi de suite...
compteur va valoir progressivement 0, 1, 2, 3, ..., 8, 9, et 10. Lorsque
compteur vaut 10, l'expression "
compteur < 10" renvoie
FALSE. Donc, on sort de la boucle.
On pourrait voir d'ailleurs que la variable
compteur augmente au fur et à mesure dans la boucle, en l'affichant dans le
write :
Code : Pascal 1
2
3
4
5
6
7
8
9
10 | var compteur:integer;
begin
compteur := 0;
while compteur < 10 do
begin
writeln('compteur vaut ', compteur);
inc(compteur, 1);
end;
end.
|
| compteur vaut 0
compteur vaut 1
compteur vaut 2
compteur vaut 3
compteur vaut 4
compteur vaut 5
compteur vaut 6
compteur vaut 7
compteur vaut 8
compteur vaut 9 |
Voilà, si vous avez compris ça, vous avez tout compris.
Vous pouvez vous amuser à augmenter la limite du nombre de boucles ("
< 100" au lieu de "
< 10").
Gare aux boucles infinies
Lorsque vous créez une boucle, assurez-vous toujours qu'elle peut s'arrêter à un moment ! Si l'expression renvoie toujours
TRUE, votre programme ne s'arrêtera jamais !
Voici un exemple de boucle infinie :
Code : Pascal1
2
3
4 | while TRUE do
begin
writeln('Mais qui va arrêter cette boucle ?');
end;
|
Souvenez-vous des booléens :
TRUE = vrai,
FALSE = faux. Ici, c'est toujours
TRUE, donc ce programme affichera : "Mais qui va arrêter cette boucle ?" sans arrêt !
Pour arrêter une boucle infinie, si vous avez créé un .exe, arrêtez tout simplement la console : sous le compilateur que je vous ai donné, cliquez sur la petite fenêtre Windows entre Ctrl et Alt.
Mais le meilleur moyen reste quand même de ne pas en faire.
Ce type de boucle est très similaire à
while, bien qu'un peu moins utilisé, en général.
La seule chose qui change en fait par rapport à
while, c'est la position de la condition. Au lieu d'être au début de la boucle,
la condition est à la fin :
Code : Pascal1
2
3
4
5
6
7
8
9 | var compteur:integer;
begin
compteur := 0;
repeat
writeln('compteur vaut ', compteur);
inc(compteur, 1);
until compteur = 10;
end.
|
Qu'est-ce que ça change ?
C'est très simple : la boucle
while pourrait très bien ne jamais être exécutée si la condition est fausse dès le départ. Par exemple, si on avait initialisé le compteur à 50, la condition aurait été fausse dès le début, et on ne serait jamais rentrés dans la boucle.
Pour la boucle
repeat ... until, c'est différent : cette boucle s'exécutera toujours au moins une fois. En effet, le test se fait à la fin, comme vous pouvez le voir. Si on initialise compteur à 50, la boucle s'exécutera une fois.
Il est donc parfois utile de faire des boucles de ce type, pour s'assurer que l'on rentre au moins une fois dans la boucle. C'est quand même plus rare.
repeat veut dire, en français, répète, et until, jusqu'à ce que. La boucle va donc se répéter JUSQU'A CE QUE LA CONDITION SOIT VERIFIEE, et non pas tant qu'elle est fausse !
En théorie, la boucle
while permet de réaliser toutes les boucles que l'on veut.
Toutefois, tout comme le "
case ... of ... end ..." pour les conditions, il est dans certains cas utiles d'avoir un autre système de boucle plus "condensé", plus rapide à écrire.
Les boucles
for sont très très utilisées en programmation. Je n'ai pas de statistiques sous la main, mais sachez que vous utiliserez certainement autant de
for que de
while, donc il vous faudra savoir manipuler ces deux types de boucles.
Comme je vous le disais, les boucles
for sont juste une autre façon de faire une boucle
while.
Voici un exemple de boucle
while que nous avons vu tout à l'heure :
Code : Pascal 1
2
3
4
5
6
7
8
9
10 | var compteur:integer;
begin
compteur := 0;
while compteur < 10 do
begin
writeln('compteur vaut ', compteur);
inc(compteur, 1);
end;
end.
|
Voici maintenant l'équivalent en boucle
for :
Code : Pascal1
2
3
4
5
6
7
8 | var compteur:integer;
begin
for compteur := 0 To 10 do
begin
writeln('compteur vaut ', compteur);
end;
end.
|
Quelles différences ?
- Vous noterez qu'on n'a pas initialisé la variable compteur à 0 (mais on aurait pu le faire).
- Il y a beaucoup de choses après le for (nous allons détailler ça après).
- il n'y a plus de inc(compteur, 1);.
Intéressons-nous maintenant à ce qu'il y a après le
for :
Code : Pascal1 | for compteur := 0 To 10 do
|
- compteur := 0 : cette première instruction est utilisée pour préparer notre variable compteur. Dans notre cas, on initialise la variable à 0.
- To 10 : la seconde signifie "à quel nombre va s'arrêter la boucle", et "va-t-on incrémenter ou pas ?". Pour changer le "sens", donc, pour décrémenter, on utilisera downto, puis le nombre jusqu'auquel la boucle va s'arrêter.
Bref, comme vous le voyez, la boucle
for n'est rien d'autre qu'un condensé.
Sachez vous en servir, vous en aurez besoin plus d'une fois !
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
81 Zéros connectés |
8 requêtes |
0.0779s (0.0665s)
