Les structures itératives

1. Définition

Comme indiqué dans le premier chapitre, la boucle est la quatrième grande structure 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 quatre 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 novice à cause des fameux critères de sortie. Si les tests exécutent une action donnée (structure SI) en cas de réussite ou non...

Tant Que

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 
  Cpt1 
  Tant que Cpt<=10 Faire 
    Afficher Cpt 
    CptCpt+1 
  FinTantQue 
FIN

En PHP, la boucle "Tant Que" 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 PHP correspondant à l’algorithme TQUE1 :

<html> 
  <head><meta/> 
    <title>tque1</title> 
  </head> 
  <body> 
   <?php 
 
  $cpt=1; 
  while($cpt<=10) { 
    echo "$cpt<br />"; 
    $cpt++; 
  } 
  ?> 
  </body> 
</html>

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...

Répéter … Jusqu’à

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 :

Quoi qu’il arrive, il y aura toujours au moins un passage dans la boucle : le bloc d’instructions sera exécuté au moins une fois.
L’expression booléenne finale est inversée. Un " tant que a !=1 " devient un "jusqu’à a=1".

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 ...

Pour … Fin Pour

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.

Il n’existe aucun cas où la structure "Pour … Fin Pour" est strictement nécessaire. Elle ne fait que simplifier les autres structures itératives lors de l’utilisation de compteurs.

3. Quelle structure...

Exercices

Exercice 1

Écrire un algorithme qui demande un nombre de départ, et qui calcule ensuite la somme des entiers jusqu’à ce nombre. Exemple avec le nombre 6 :

1+2+3+4+5+6 = 21