Structures répétitives

01 - Introduction 03 - La boucle WHILE
02 - La boucle FOR 04 - Exercices

01

Introduction

Dans le chapitre sur la structure alternative, on a vu comment on peut utiliser cette structure de contrôle pour modifier la direction dans laquelle le programme doit évaluer. Il est ainsi possible d'exécuter l'un ou l'autre bloc d'instructions sur base d'un test logique, c.-à-d. suivant qu'une condition est vraie ou fausse.

La structure répétitive est une autre structure de contrôle, qui permet cependant d'exécuter une portion de code plusieurs fois de suite. Le terme le plus utilisé pour une structure répétitive est celui d'une « boucle ».

Delphi offre plusieurs types de boucles différents, qui s'exécutent selon le cas, soit un nombre de fois connu à l'avance, soit jusqu'à ce qu'une condition permette de sortir de la boucle.

02

La boucle FOR

Ce type de boucle est utilisé lorsqu'une ou plusieurs instructions sont exécutées un nombre précis de fois, c.-à-d. lorsque le nombre de répétitions est connu d'avance.

La boucle FOR utilise une variable compteur, qui est une variable de type entier, pour déterminer le nombre d'itérations (une itération est une répétition du corps de la boucle) et qui est modifiée lors de chaque itération. La valeur du compteur détermine la condition d'arrêt de la boucle.

La boucle FOR ... TO

Cette structure permet de répéter une ou plusieurs instructions un nombre précis de fois, en comptant d'une valeur de départ jusqu'à une valeur finale. La valeur du compteur est incrémentée (ou encore augmentée) de 1 lors de chaque itération de la boucle.

La forme générale d'une telle boucle est donc la suivante :

for <compteur> := <valeur initiale> to <valeur finale> do <instruction>;

Les valeurs initiales et finales (et donc le nombre d'itérations) sont calculées une fois pour toute avant l'entrée dans la boucle. Elles ne sont plus réévaluées plus tard et il n'est donc pas possible d'influencer le nombre d'itérations par la suite.

Pour une valeur initiale a et une valeur finale b, le nombre d'itérations est de (b-a)+1. Si la valeur finale est égale à la valeur initiale, le corps de la boucle est donc exécuté une seule fois. Si la valeur finale est inférieure à la valeur initiale, le corps de la boucle n'est pas exécuté du tout.

Exemple 1

On souhaite afficher le message « Hello World » dix fois de suite à la console. Bien sûr, ceci ne nécessite pas forcément une boucle est peut s'écrire de la manière suivante :

Affichage de dix fois 'Hello World' - version sans boucle
program hello1;

begin
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
  writeln('Hello World');
end.

Cependant, comme une instruction est répétée plusieurs fois et que ce nombre est connu d'avance (ici ce nombre est 10), on peut utiliser une boucle FOR pour simplifier le code de ce programme :

Affichage de dix fois 'Hello World' - version avec boucle
program hello2;

var
  i : integer;

begin
  for i := 1 to 10 do
    writeln('Hello World');
end.

Exemple 2

On souhaite demander un nombre naturel à l'utilisateur et afficher le message « Hello World » autant de fois à la console. Ceci est presque impossible à réaliser sans boucle (il faudrait envisager une immense structure alternative qui prend en compte toutes les valeurs possibles que l'utilisateur pourrait entrer) et le code source d'un tel programme est le suivant :

Affichage de 'Hello World' un certain nombre de fois
program hello3;

var
  nombre, i : integer;

begin
  readln(nombre);
  for i := 1 to nombre do
    writeln('Hello World');
end.

Exemple 3

On souhaite afficher tous les nombres entiers de 5 à 10 à la console. Dans cet exemple, l'instruction qui est répétée exploite l'information du compteur pour afficher une information variable dans le temps à la console.

Affichage des nombres entiers de 5 à 10
program nombres;

var
  i : integer;

begin
  for i := 5 to 10 do
    writeln(i);
end.

La boucle FOR ... DOWNTO

Ce type de boucle diffère peu de la boucle FOR ... TO. En effet, la seule différence est que la variable compteur et décrémentée (ou encore diminuée) de 1 lors de chaque itération de la boucle. La valeur initiale est donc supérieure ou égale à la valeur finale de la variable compteur.

La forme générale d'une boucle FOR ... DOWNTO est :

for <compteur> := <valeur initiale> downto <valeur finale> do <instruction>;

Il est tout à fait possible de transformer une boucle FOR ... DOWNTO en une boucle FOR ... TO et vice-versa. Dans la vie pratique, la boucle FOR ... DOWNTO est peu utilisée.

Exemple 1

On souhaite afficher tous les nombres entiers de 10 à 1 à la console.

Affichage des nombres entiers de 10 à 1 - boucle FOR ... DOWNTO
program nombres1;

var
  i : integer;

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

On peu aussi utiliser une boucle FOR ... TO pour afficher tous les nombres entiers de 10 à 1 à la console:

Affichage des nombres entiers de 10 à 1 - boucle FOR ... TO
program nombres2;

var
  i : integer;

begin
  for i := 1 downto 10 do
    writeln(11-i);
end.

03

La boucle WHILE

Ce type de boucle est utilisé lorsqu'une ou plusieurs instructions sont exécutées aussi longtemps qu'une certaine condition est vraie. Le nombre de répétitions de cette boucle n'est donc pas connu d'avance.

La boucle WHILE utilise une condition d'arrêt, qui est un test logique, pour déterminer le nombre d'itérations. Le corps de la boucle est exécuté aussi longtemps que la condition d'arrêt est vraie. La condition d'arrêt est revérifiée à chaque itération afin de déterminer si le corps de la boucle est exécuté encore une fois.

La forme générale d'une telle boucle est la suivante:

while do ;

Comme la condition est vérifiée au début de la boucle, il se peut que le corps de la boucle soit exécuté aucune fois.

Exemple

On souhaite calculer et afficher la factorielle de 5 à la console.

Affichage de la factorielle de 5
program fact5;

var
  resultat, facteur : integer;

begin
  resultat:=1;
  facteur:=5;

  while facteur > 1 do
    begin
      resultat:=resultat*facteur;
      facteur:=facteur-1;
    end;

  writeln(resultat);
end.

La boucle infinie

Comme le nombre d'itérations d'une boucle WHILE dépend uniquement de la condition d'arrêt, il se peut qu'une condition mal conçue produise une boucle qui ne s'arrête jamais. Ceci est effectivement le cas lorsque la condition d'arrêt est toujours vraie. Une telle situation peut par exemple se produire lorsque la condition d'arrêt ne dépend pas d'une valeur modifiée à l'intérieur de la boucle, mais aussi dans d'autres situations, comme le montre l'exemple suivant.

Exemple d'une boucle infinie
program boucle_infinie;

var
  i : integer;

begin
  i := 5;
  while (sqr(i) >= 0) do
    i := i - 1;
end.

04

Exercices

  1. Donnez la définition des mots suivants:
    1. itération
    2. incrémenter
    3. décrémenter
    4. variable compteur
  2. Énumérez les différents types de boucles et expliquez leur utilité.
  3. Écrivez un programme qui demande à l'utilisateur deux nombres relatifs a et b et qui affiche tous les nombres entiers entre a et b. Il n'est pas nécessaire que b soit supérieur à a.
Sign In