Les boucles

1. Définition

Comme indiqué dans le premier chapitre, la boucle fait partie des grandes structures de base de l’algorithmique, et donc de la programmation. Passé ce chapitre, tout le reste est une application ou une dérivation de ces structures de base. Les boucles sont des structures itératives. Une itération ou structure itérative est une séquence d’instructions destinée à être exécutée plusieurs fois. C’est aussi l’action d’exécuter cette instruction. Vous entendrez parler parfois de structures répétitives, c’est la même chose dite autrement. Le but d’une boucle est de répéter un bloc d’instructions plusieurs fois. Selon le type de boucle, ce bloc va être répété un nombre fixe de fois (n fois) ou selon un certain nombre de critères (un test de une ou plusieurs conditions) que vous connaissez très bien maintenant.

La boucle est un élément très simple au premier abord. Les premiers exemples que vous rencontrerez seront bien souvent évidents. Pourtant elle devient rapidement l’une des bêtes noires du programmeur en herbe à cause justement des fameux critères de sortie. Si les tests exécutent une action donnée (structure SI) en cas de réussite ou non...

1. Structure générale

La boucle de type Tant Que permet la répétition d’un bloc d’instructions tant que la condition testée est vérifiée, donc vraie. Sa syntaxe est la suivante :

Tant Que booléen Faire 
  Bloc d'instructions 
FinTantQue
 

Lors de l’exécution du programme, celui-ci arrive sur l’instruction Tant que. Il évalue l’expression booléenne (une ou plusieurs conditions, ou une seule variable). Si l’expression retourne VRAI, alors le programme exécute les instructions suivantes jusqu’à ce qu’il arrive au FinTantQue.

Arrivé ici, il remonte au Tant Que et évalue de nouveau l’expression booléenne. Si c’est VRAI alors il exécute de nouveau les instructions, et ainsi de suite, tant que l’expression retourne VRAI. Si l’expression devient fausse, alors le programme saute à l’instruction située juste après le FinTantQue. Voici un simple exemple qui compte de 1 à 10 :

PROGRAMME TQUE1 
VAR 
  Cpt:entier 
DEBUT 
  Cpt←1 
  Tant que Cpt<=10 Faire 
    Afficher Cpt 
    Cpt←Cpt+1 
  FinTantQue 
FIN
 

En C#, la boucle TantQue est représentée par while(), avec l’expression booléenne entre parenthèses.

while(booleen) { 
  /* bloc d'instructions */ 
}
 

Si une seule instruction est présente au sein de la boucle, les accolades sont inutiles.

while(booléen) instruction;
 

Voici le code C# correspondant à l’algorithme TQUE1 :

class chap4_tq1 
{ 
    static void Main(string[] args) 
    { 
        int cpt = 1; 
 
        while (cpt <= 10) 
        { 
            System.Console.WriteLine(cpt); 
            cpt++; 
        } 
    } 
}
 

2. Boucles infinies et "break"

Faites toujours bien attention à ce que votre boucle dispose d’une condition de sortie. En effet rien ne vous empêche de faire des boucles infinies. Dans le cas d’une structure itérative Tant Que, il suffit que la condition soit toujours VRAIE...

1. Différences fondamentales

Malgré l’abondance d’exemples vus jusqu’à présent, la structure itérative Tant Que n’est pas la seule. Même s’il est possible de tout programmer avec ce type de boucle, il en manque encore deux, dont la structure Répéter ... Jusqu’à. Son pseudo-code est le suivant :

Répéter 
  Bloc d'instructions 
Jusqu'à booléen
 

Le Répéter ressemble fortement au Tant que avec cependant deux importantes différences :

Le jusqu’à se comprend comme "jusqu’à ce que la condition soit vérifiée". Pour faire une boucle infinie il faut donc faire :

Répéter 
  Bloc d'instructions 
Jusqu'à FAUX
 

Pour reprendre l’algorithme de saisie du relevé de notes qui avait posé quelques problèmes, celui-ci devient un peu plus simple :

PROGRAMME REPETE 
VAR 
Note:entier 
Début 
Répéter 
    Ecrire "Saisissez une note" 
    Lire note 
    Si note<-1 OU note>20 Alors 
      Répéter 
        Ecrire "Erreur (0->20, -1 sortie) :" ...

1. Une structure pour compter…

Troisième et dernière structure itérative de l’algorithmique, le Pour ... Fin Pour est une boucle à l’usage quasi-exclusif des compteurs. À chaque passage dans la boucle, un compteur est incrémenté ou décrémenté, selon le cas. On dit alors qu’il s’agit d’une structure incrémentale.

Sa syntaxe en pseudo-code est la suivante :

Pour variable De début à fin [PAS pas] Faire 
  Bloc d'instructions 
Fin Pour
 

À chaque passage dans la boucle, la variable prendra successivement chacune des valeurs dans l’intervalle [a;b] (a et b inclus). Le pas est optionnel et est de 1 par défaut. Le pseudo-code suivant compte de 1 à 10 :

Variable cpt en Numérique 
Début 
  Pour cpt De 1 à 10 Faire 
    Ecrire cpt 
  Fin Pour 
Fin
 

Il est possible de trouver des syntaxes légèrement différentes, elles sont cependant toutes équivalentes :

Pour variable Allant De début à fin [pas pas] Faire 
  Bloc d'instructions 
Fin Pour
 

Ou encore :

Pour compteur ← début à fin [Pas pas] 
  Bloc d'instructions 
compteur suivant
 

Dans cette dernière forme, il est intéressant de constater qu’il est plus simple, dans le cas de boucles contenant un gros bloc d’instructions, de s’y retrouver, la variable étant répétée dans la syntaxe de fin de boucle. Enfin il est possible de trouver des syntaxes alternatives dérivant de ces trois dernières.

2. … mais pas indispensable

Vous aurez rapidement compris que cette boucle ne sert que pour des compteurs. Autrement dit, tout ce qu’elle propose est déjà intégralement possible avec les structures Tant Que et Répéter Simplement avec le Pour vous n’avez pas à faire vous-même le calcul du compteur. C’est donc une simplification.

3. Quelle structure choisir ?

Mais alors quand utiliser telle ou telle structure ? On emploie une structure Pour lorsqu’on connaît...