Boucles à bornes définies
Nous considérons formellement :
-
une variable de contrôle de boucle (notée i pour l'explication)
-
une borne inférieure (notée valeur_inf pour l'explication)
-
une borne supérieure (notée valeur_sup pour l'explication)
-
une instruction d'initialisation de la variable de contrôle de boucle (i)
-
une condition logique entre la variable de contrôle de boucle i et la borne inférieure (valeur_inf) ou entre la variable i et la borne supérieure (valeur_sup)
-
une instruction faisant évoluer la valeur de la variable de contrôle de boucle (i)
Nous supposons que la variable i a été préalablement correctement déclarée.
Nous souhaitons écrire un programme qui affiche les trois premiers chiffres : 0, 1, 2.
Pour cela, dans le langage algorithmique, nous écrivons :
instruction_avant
pour i variant de 0 à 2 avec un pas de 1
afficher(i)
instruction_après
Cette boucle utilise implicitement les notions d'étiquette, de branchement conditionnel et de branchement inconditionnel vers une étiquette.
De façon équivalente, on pourrait écrire :
instruction_avant
i = 0
Étiquette 1 : si (i<3)
alors
afficher(i)
i = i + 1
aller à Etiquette 1
sinon
aller à Etiquette 2
Étiquette 2 :
instruction_après
Pour décrire graphiquement le fonctionnement de cette boucle, nous introduisons l'organigramme suivant qui permet de suivre le déroulement des instructions :
Dans un organigramme, une instruction est placée dans un rectangle. Un losange correspond à un test. Le résultat du test vaut soit vrai soit faux. Les flèches indiquent très clairement l'enchaînement des instructions. La lecture de l'organigramme se fait du haut vers le bas. La boucle "pour" correspond au rectangle dessiné en pointillé.
« instruction_avant » est l'instruction exécutée avant la boucle.
« instruction_après » est l'instruction exécutée après la boucle.
La variable de contrôle de boucle a pour identificateur i, la valeur 0 correspond à la borne inférieure (valeur_inf), la valeur 3 correspond à la borne supérieure (valeur_sup), l'instruction d'initialisation est i =0, la condition logique est i<3 et enfin l'instruction faisant évoluer la valeur de la variable de contrôle de boucle i est i = i+1 (car nous avons précisé que le pas était de 1). Le bloc d'instructions exécutées à chaque itération est ici réduit à une seule instruction "afficher" qui affiche la valeur de la variable de contrôle de boucle i.
Ceci est conforme à la syntaxe :
instruction_avant
pour i variant de 0 à 2 avec un pas de 1
debut
afficher(i)
fin
instruction_après
Le fonctionnement de la boucle "pour" se comprend très facilement si l'on s'appuie sur l'organigramme : L'instruction « instruction_avant » est exécutée. Puis la boucle « pour » commence. La valeur 0 est affectée à la variable de contrôle de boucle i.
-
La condition logique i<3 (i vaut 0) est évaluée, le résultat du test vaut "vrai". Le bloc d'instructions s'effectue et i=0 s'affiche à l'écran. La première itération est terminée. L'instruction i=i+1 faisant évoluer la valeur de la variable de contrôle de boucle est effectuée, i vaut 1. Un branchement est automatiquement effectué pour que la condition logique soit à nouveau évaluée.
-
La condition logique i<3 est évaluée (i vaut 1), le résultat du test vaut "vrai". Le bloc d'instructions s'effectue et i=1 s'affiche à l'écran. La seconde itération est terminée. L'instruction i=i+1 fait évoluer la valeur de la variable de contrôle de boucle, i vaut 2. Un branchement est automatiquement effectué pour que le test soit à nouveau évalué.
-
La condition logique i<3 est évaluée (i vaut 2), le résultat du test vaut "vrai". Le bloc d'instructions s'effectue et i= 2 s'affiche à l'écran. La troisième itération est terminée. L'instruction i=i+1 fait évoluer la valeur de la variable de contrôle de boucle, i vaut 3. Un branchement est automatiquement effectué pour que le test soit à nouveau évalué. • La condition logique i<3 est évaluée (i vaut 3), le résultat du test vaut "faux". Un branchement est automatiquement effectué pour exécuter la suite du programme. La boucle « pour » est terminée. « instruction_apres » est exécutée.
La boucle effectue simplement l'affichage de la variable de contrôle de boucle i. Cette variable prend successivement les valeurs 0, 1, 2, 3. Mais l'extrait de code affiche uniquement les valeurs : 0, 1 et 2.
Vous remarquerez que pour terminer la boucle, la condition logique i<3 doit être fausse. Ce qui signifie que i vaut 3 après la boucle car sa valeur n'a pas changé après la dernière instruction i=i+1.
Vous remarquerez également que l'instruction faisant évoluer la valeur de la variable de contrôle de boucle est effectuée APRES les instructions du bloc et AVANT le branchement. Elle est automatiquement générée à partir de l'écriture "avec un pas de 1" dans la syntaxe de la boucle.
Nous pourrons prendre quelques libertés avec la syntaxe du "pour". Par exemple, si les pas d'incrémentation sont toujours de 1, on pourra simplement écrire :
pour i variant de 0 à 2
debut
afficher(i)
fin
On dit que ce sont des boucles à bornes définies car on connaît exactement le nombre d'itérations qu'effectuera la boucle. A ce stade, les notations et les bases sont établies et nous allons les utiliser pour présenter les boucles à bornes non définies.
