CyBWarrior

1. For…To…Do et For…DownTo…Do
2. Repeat…Until
3. While…Do
4. Break

Plutôt que d’écrire plusieurs fois les mêmes instructions pour un même résultat,
on peut créer une boucle qui nous évitera bien du travail.

For…To…Do et For…DownTo…Do

Ces deux boucles permettent de répeter un groupe d’instruction tout en
incrémentant ou décrémentant une variable.

Ceci peut être très utile : imaginez que vous vouliez apprendre la table
de 8.

On pourrait écrire 10 fois writeln(’1 x 8 = ‘, 1 * 8); à
chaque fois, mais ce n’est pas très astucieux.

L’alternative proposée ci-dessous permet d’obtenir le même résultat, mais
en une seul et unique ligne, grace à la boucle For…To…Do :

program Table8;

var i : integer;
begin

  { utilisation d’une boucle pour calculer la table de 8 }

  For i := 1 To 10 Do writeln(i, ‘ x 8 = ‘, i * 8);

end.

La syntaxe de cette boucle est la suivant :

For var := min To max Do [Instruction];

ou
For var := min To max Do

Begin

  [Instruction];

  [Instruction];

End;

var représente une variable de type Integer.
min et max peuvent être des variables ou des constantes,
mais doivent aussi être du type Integer.

La boucle va incrémenter la variable d’une unité à chaque fois. Lorque celle
ci va atteindre la valeur spécifiée par max, l’execution de
la boucle s’arrétera et les instructions suivantes seront executées.

La boucle For…DownTo…Do est identique à la précedente. La seule
différence réside dans le fait que la variable n’est pas incrémentée mais
décrémentée.

Si on avait voulu faire la table de 8 à l’envers, on aurrait écrit :

program Table8;

var i : integer;
begin

  { Boucle DownTo pour la table de 8 à rebourd }

  For i := 10 DownTo 1 Do writeln(i, ‘ x 8 = ‘, i * 8);

end.

On peut tout à fait imbriquer des boucles les unes dans les autres.

Le court programme ci-dessous permet d’afficher les tables de multiplication
de 1 à 10 :

program Tables;

var i : integer;

    j : integer;
begin

  For i := 1 To 10 Do

    For j := 1 To 10 Do writeln(j, ‘ x ‘, i, ‘ = ‘, j * i);

end.

Repeat…Until

Repeat…Until permet de répeter au moins une fois une ou
plusieurs instructions, juqu’à ce qu’une condition soit évaluée comme
vraie.

Voici la syntaxe :

Repeat

  [Instruction];

  [Instruction];

Until condition;

Pourquoi au moins une fois ? Parce que comme vous le voyez, la condition
est située à la fin de la boucle, devant Until.

La condition peut être n’importe quel test, comme nous l’avons vu dans
la structure conditionnelle.

Vous remarquez qu’il n’y a pas besoin de définir un bloc d’instructions
avec Begin…End.

var Age : Integer;

begin

  Repeat

    Writeln(’Quel est votre age ?’);

    Readln(Age);

  Until Age >= 18;

  Writeln(’C »est bon, vous êtes majeur.’);

end.

While…Do

On peut dire que la boucle While…Do est l’inverse de la boucle
Repeat…Until.

En effet, While…Do fait se répeter une ou plusieurs instructions
tant qu’ une condtion est vraie.

Le test se situant en tête de boucle, les instructions ne sont pas obligatoirement
répetées au moins une fois.

Voici la syntaxe :

While condition Do [Instruction];

ou
While condition Do

Begin

  [Instruction];

  [Instruction];

End;

On peut reprendre l’exemple de la boucle Repeat…Until ainsi :

var Age : Integer;

begin

  While Age < 18 Do

  Begin

    Writeln('Quel est votre age ?');

    Readln(Age);

  End;

  Writeln('C''est bon, vous êtes majeur.');

end.

Break

L’instruction Break permet de sortir de n’importe quel boucle étudiée
plus haut. L’exemple suivant n’affiche rien, puisque l’instruction Break
est appelée tout au début de la boucle :

program Tables;

var i : integer;

    j : integer;
begin

  For i := 1 To 10 Do

  begin

    Break;

    For j := 1 To 10 Do writeln(j, ‘ x ‘, i, ‘ = ‘, j * i);

  end;

end.

Series Navigation

«Turbo Pascal – BranchementsTurbo Pascal – Procédures et fonctions»