Langage Pascal/Instruction itérative

Début de la boite de navigation du chapitre

fin de la boite de navigation du chapitre

Les instructions itératives

Nous avons déjà vu comment créer des tableaux. Si vous désirez calculer la somme des entiers contenu dans un tableau sans structure intérative, vous devrez faire ainsi :

var
    t : array[1..5] of integer;
    somme : integer;

begin
    {initialisation du tableau}

    {calcul de la somme}
    somme := 0;
    somme := somme + t[1];
    somme := somme + t[2];
    somme := somme + t[3];
    somme := somme + t[4];
    somme := somme + t[5];

    writeln(somme);
end.

Ainsi, le programme affiche le résultat de la somme des cinq entiers contenus dans le tableau. Pour le moment, tout à l'air simple, mais le tableau ne contient que cinq entiers. Et si le tableau contenait plus de 1.000 entiers ? Un tel nombre de copier/coller n’est pas acceptable. Pour cela, il existe un moyen de "factoriser" le code grâce à une boucle. Avec une structure itérative, on obtient ceci :

var
    t : array[1..5] of integer;
    somme : integer;
    i: integer;

begin
    {initialisation du tableau}

    {calcul de la somme}
    somme := 0;
    for i := 1 to 5 do
      somme := somme + t[i];

    writeln(somme);
end.

while … do …

While…Do fait se répeter une ou plusieurs instructions tant qu’ une condition 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
  Age := 0; { il faut initialiser Age avec une valeur qui soit inférieure à 18, sinon, la question ne sera pas posée }
  While Age < 18 Do
  Begin
    Writeln('Quel est votre age ?');
    Readln(Age);
  End;
  Writeln('C’est bon, vous êtes majeur.');
end.

repeat … until …

Repeat…Until permet de répéter au moins une fois une ou plusieurs instructions, jusqu’à ce qu’une condition soit évaluée comme vraie. On peut dire que la boucle Repeat…Until est l’inverse de la boucle While…Do.

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.

Il n’est pas nécessaire de définir un bloc d’instructions avec Begin…End. Cette structure est donc une exception à la règle.

var Age : Integer;
begin
  Repeat
    Writeln('Quel est votre age ?');
    Readln(Age);
  Until Age >= 18;
  Writeln('C’est bon, vous êtes majeur.');
end.

for … to … do …

Il existe deux formes de boucle for. La première consiste à parcourir des nombres dans l’ordre croissant :

var i: integer;

begin
     for i := 1 to 3 do
       writeln(i);
end;

On obtiendra les nombre de 1 à 3 dans cet ordre.

On peut aussi parcourir dans l’ordre décroissant :

var i: integer;

begin
     for i := 3 downto 1 do
       writeln(i);
end;

On obtiendra les nombre de 3 à 1 dans l’ordre décroissant.

Erreur à éviter :

var i: integer;

begin
     for i := 1 downto 3 do  { les bornes ne sont pas dans le bon ordre }
       writeln(i);
end;

On obtiendra rien du tout en sortie. En effet, le compteur sera initialisé à 1, puis comparé à 3, et comme il est plus grand que 3, même la première itération ne se fera pas.