Les boucles



Tout comme les conditionnelles, les boucles sont des structures de contrôle fondamentales de la programmation.

Par l'intermédiaire d'une boucle, on peut demander à un ordinateur de répéter une partie de code.

Nous allons présenter trois types de boucle: les boucles While, les boucles Repeat et les boucles For.

En fait, la boucle While suffirait à écrire n'importe quel programme. Mais dans certains cas l'écriture d'une boucle avec repeat ou avec for est plus pratique.

I - Les boucles While

Une boucle While permet de répéter du code tant qu'une certaine condition est vraie.

Elle s'écrit de la manière suivante : 

While condition do
begin
 Instructions à répéter
 tant que la condition est vraie
End ;

La condition est une expression logique quelconque.

Voilà un exemple précis de boucle While : 

S := 0;
i := 1;
While i <= n Do
begin 
     S := S + i;
     i := i + 1;
End;

Cette boucle permet de calculer la somme S des n premiers entiers : 1+2+3+...+n. Pour n = 4, on aura par exemple S=1+2+3+4= 10 à la fin de l'exécution de ce code.

Vocabulaire associé aux boucles

Un peu de vocabulaire:

Chaque exécution du code à l'intérieur d'une boucle s'appelle une itération

Dans notre exemple une itération est une exécution des instructions S := S + i; et i := i + 1;.

Généralement une boucle est précédée d'un certains nombre d'affectations que l'on appelle des initialisations. Elles servent à donner des valeurs initiales aux variables de la boucle (c'est à dire toutes celles qui vont varier dans la boucle).

Dans notre exemple, ce sont les instructions S := 0 et i := 1.

Dans une boucle on trouve fréquemment une variable qui joue le rôle de compteur (car elle compte en quelque sorte le nombre d'itérations). La valeur de cette variable est augmentée de 1 à chaque itération par une instruction de la forme variable := variable + 1 que l'on appelle une incrémentation.

Dans notre exemple, le compteur est représenté par la variable i. A chaque itération, la valeur de i est incrémentée par l'affectation i := i + 1.

Déroulement de la boucle

Nous allons à présent dérouler la boucle donnée en exemple, c'est à dire détailler toutes les instructions qui seront exécutées jusqu'à ce que la boucle s'arrête.

Supposons que n vaut 3 avant d'entrer dans la boucle. Voilà exactement ce qu'il se passe lorsque cette boucle est exécutée :

Instruction exécutée Valeur de i Valeur de S
S := 0 0 0 Initialisation
i := 1 1 0
S := S + i 1 1 1ère itération
i := i + 1 2 1
S := S + i 2 3 2ème itération
i := i + 1 3 3
S := S + i 3 6 3ème itération
i := i + 1 4 6

Dans une boucle While, la condition d'arrêt est testée avant l'exécution d'une itération.

Donc avant d'entrer la première fois dans la boucle, l'ordinateur va tester la condition i ≤ n. Comme i vaut 1 et n vaut 3, il va rentrer dans la boucle et faire une première itération.

A la fin de la première itération i vaut 2. La condition i ≤ n est toujours vérifiée. L'ordinateur va donc faire une deuxième itération.

A la fin de la deuxième itération i vaut 3. La condition i ≤ n est toujours vérifiée. L'ordinateur va donc faire une troisième itération.

A la fin de la 3ème itération, i vaut 4. Ce sera donc la dernière itération car à présent la condition i ≤ n est fausse.

II - Les boucles Repeat

La boucle Repeat s'écrit de la manière suivante: 

 Repeat
   Instructions à répéter
   jusqu'à ce que la condition soit vraie
 Until condition

Remarques:

Voici par exemple comment calculer la somme des n premiers nombres entiers avec une boucle Repeat: 

S := 0;
i := 0;
Repeat
  i := i + 1;
  S := S+ i 
Until i = n;

Comme précédement, supposons que n vaut 3 et voyons ce qui se passe exactement lorsque la boucle Repeat est exécutée:

Instruction exécutée Valeur de i Valeur de S
S := 0 0 0 Avant d'entrer
dans la boucle
i := 0 0 0
i := i + 1 1 0 1ère itération
S := S + i 1 1
i := i + 1 2 1 2ème itération
S := S + i 2 3
i := i + 1 3 3 3ème itération
S := S + i 3 6

Avant d'entrer dans la boucle S et i sont initialisés à 0.

A la fin de chaque itération, l'ordinateur va tester si i est égal à n (donc 3 dans notre exemple).

Cette condition n'est réalisée qu'à la fin de la troisième itération.

III - Les boucles For

Fondamentalement une boucle For n'est rien d'autre qu'un raccourci d'écriture pour un certain type de boucle While que l'on rencontre très fréquemment : 

compteur := valeur initiale;
While compteur <= valeur finale Do
Begin
   Instructions à répéter 
   compteur := compteur + 1;
End

Avant la boucle, on affecte une valeur initiale au compteur.

A chaque itération le compteur est incrémenté.

La boucle s'arrête dès que le compteur dépasse la valeur finale.

La boucle For permet d'écrire ce type de boucle de manière plus concise, comme suit 

 
For compteur :=  valeur initiale To valeur finale Do
Begin
   Instructions à répéter
End;

On économise donc ainsi l'écriture de l'incrémentation du compteur à l'intérieur de la boucle.

Attention: l'incrémentation du compteur n'est pas écrite, mais elle est bien exécutée.

Voici par exemple la somme des n premiers nombres entiers avec une boucle For et avec une boucle While :

En boucle For En boucle While 
  
S := 0; 
For i :=  1 To n Do
Begin
   S := S+i 
End

  
S := 0;
i := 1;
While i <= n Do
Begin
  S := S+i;
  i := i+1 

End