Nous souhaitons créer un programme nous affichant tous les nombres de 1 à 5, donc dont l’exécution serait la suivante :
1 2 3 4 5
Une façon particulièrement vilaine de procéder serait d’écrire 10
sysout successifs, avec la laideur des
copier/coller que cela impliquerait. Nous allons étudier un moyen de
mettre au point ce type de programme avec un peu plus d’élégance.
Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions. Cette ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du corps d’une boucle s’appelle une itération, ou plus informellement un passage dans la boucle. Lorsque l’on s’apprête à exécuter la première itération, on dit que l’on rentre dans la boucle, lorsque la dernière itération est terminée, on dit qu’on sort de la boucle.
Il existe trois constructions de boucles :
Chacune de ces boucles a ses avantages et ses inconvénients. Nous les passerons en revue ultérieurement.
La syntaxe d’une boucle Tant que est la suivante.
La condition est évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée, on exécute les instructions de la boucle. Un fois que la condition n’est plus vérifiée, l’exécution se poursuit après le fin tant que. Affichons par exemple tous les nombres de 1 à 5 dans l’ordre croissant,
Cet algorithme initialise i à 1 et tant que la valeur de i n’excède pas 5, cette valeur est affichée puis incrémentée. Les instructions se trouvant dans le corps de la boucle sont donc exécutées 5 fois de suite. La variable i s’appelle un compteur, on gère la boucle par incrémentations successives de i et on sort de la boucle une fois que i a atteint une certaine valeur. L’initialisation du compteur est très importante ! Si vous n’initialisez pas i explicitement, alors cette variable contiendra n’importe quelle valeur et votre algorithme ne se comportera pas du tout comme prévu.
Lorsqu’une boucle fonctionne avec un compteur, n’oubliez pas :
Le fonctionnement est analogue à celui de la boucle tant que à quelques détails près :
Une boucle Répéter ... jusqu’à est donc exécutée donc au moins une fois. Reprenons l’exemple précédent avec une boucle Répéter ... jusqu’à :
De la même façon que pour la boucle Tant que, le compteur est initialisé avant le premier passage dans la boucle. Par contre, la condition de sortie de la boucle n’est pas la même, on ne sort de la boucle qu’un fois que la valeur 5 a été affichée. Or, i est incrémentée après l’affichage, par conséquent i aura la valeur 6 à la fin de l’itération pendant laquelle la valeur 5 aura été affichée. C’est pour cela qu’on ne sort de la boucle qu’une fois que i a dépassé strictement la valeur 5. Un des usages les plus courant de la boucle Répéter ... jusqu’à est le contrôle de saisie :
La boucle Pour fait varier la valeur du compteur <variable> entre <première valeur et <dernière valeur>. Le <pas> est optionnel et permet de préciser la variation du compteur entre chaque itération, le pas par défaut est 1 et correspond donc à une incrémentation. Toute boucle pour peut être réécrite avec une boucle tant que. On réécrit de la façon suivante :
La boucle pour initialise le compteur <variable> à la <première valeur>, et tant que la dernière valeur n’a pas été atteinte, les <instructions> sont exécutées et le compteur incrémenté de <pas> si le pas est positif, et décrémenté de |<pas>| si le pas est négatif.
Observez les similitudes entre cet algorithme et la version utilisant la boucle tant que. Notez bien que l’on utilise une boucle pour quand on sait en rentrant dans la boucle combien d’itérations devront être faites. Par exemple, n’utilisez pas une boucle pour pour contrôler une saisie !