Les boucles

Boucle finie, FOR (Pour)

Il arrive très souvent qu’on ait besoin d’effectuer un nombre déterminé de passages. Or, a priori, notre structure WHILE ne sait pas à l’avance combien de tours de boucle elle va effectuer (puisque le nombre de tours dépend de la valeur d’un booléen).

C’est pourquoi une autre structure de boucle est à notre disposition :

FOR var ← x TO y
    instructions
NEXT var

Insistons : la structure « FOR … NEXT » n’est pas du tout indispensable ; on pourrait fort bien programmer toutes les situations de boucle uniquement avec un « WHILE ». Le seul intérêt du « FOR » est d’épargner un peu de fatigue au programmeur, en lui évitant de gérer lui-même la progression de la variable qui lui sert de compteur (on parle d’incrémentation, encore un mot qui fera forte impression sur votre entourage).

Dit d’une autre manière, la structure « FOR … NEXT » est un cas particulier de WHILE : celui où le programmeur peut dénombrer à l’avance le nombre de tours de boucles nécessaires.

Il faut noter que dans une structure « FOR … NEXT », la progression du compteur est laissée à votre libre disposition. Dans la plupart des cas, on a besoin d’une variable qui augmente de 1 à chaque tour de boucle. On ne précise alors rien à l’instruction « FOR » ; celle-ci, par défaut, comprend qu’il va falloir procéder à cette incrémentation de 1 à chaque passage, en commençant par la première valeur et en terminant par la deuxième.

Mais si vous souhaitez une progression plus spéciale, de 2 en 2, ou de 3 en 3, ou en arrière, de –1 en –1, ou de –10 en –10, ce n’est pas un problème : il suffira de le préciser à votre instruction « FOR » en lui rajoutant le mot « STEP » et la valeur de ce pas (le « pas » dont nous parlons, c’est le « pas » du marcheur).

Naturellement, quand on stipule un pas négatif dans une boucle, la valeur initiale du compteur doit être supérieure à sa valeur finale si l’on veut que la boucle tourne ! Dans le cas contraire, on aura simplement écrit une boucle dans laquelle le programme ne rentrera jamais.

Nous pouvons donc maintenant donner la formulation générale d’une structure « FOR ». Sa syntaxe générale est :

FOR counter ← x TO y [STEP z]
    Instructions
NEXT counter

Les structures WHILE sont employées dans les situations où l’on doit procéder à un traitement systématique sur les éléments d’un ensemble dont on ne connaît pas d’avance la quantité, comme par exemple :

• le contrôle d’une saisie

• la gestion des tours d’un jeu (tant que la partie n’est pas finie, on recommence)

• la lecture des enregistrements d’un fichier de taille inconnue(cf. chapitre associé)

Les structures FOR sont employées dans les situations où l’on doit procéder à un traitement systématique sur les éléments d’un ensemble dont le programmeur connaît d’avance la quantité.

Nous verrons dans les chapitres suivants des séries d’éléments appelés tableaux et chaînes de caractères. Selon les cas, le balayage systématique des éléments de ces séries pourra être effectué par un FOR ou par un WHILE : tout dépend si la quantité d’éléments à balayer (donc le nombre de tours de boucles nécessaires) peut être dénombrée à l’avance par le programmeur ou non.

Des boucles dans des boucles

De même que les poupées russes contiennent d’autres poupées russes, de même qu’une structure IF … THEN peut contenir d’autres structures IF … THEN, une boucle peut tout à fait contenir d’autres boucles. Y a pas de raison.

ALGORITHM inside
VARIABLE
    one, second : NUMBER
BEGIN
    FOR one ← 1 TO 15
        PRINT "Il est passé par ici"
        FOR second ← 1 TO 6
            PRINT "Il repassera par là"
        NEXT second
    NEXT one
END

Dans cet exemple, le programme écrira une fois « il est passé par ici » puis six fois de suite « il repasse-ra par là », et ceci quinze fois en tout. A la fin, il y aura donc eu 15 x 6 = 90 passages dans la deuxième boucle (celle du milieu), donc 90 écritures à l’écran du message « il repassera par là ». Notez la différence marquante avec cette structure :

ALGORITHM successive
VARIABLE
    one, second : NUMBER
BEGIN
    FOR one ← 1 to 15
        PRINT "Il est passé par ici"
    NEXT one
    FOR second ← 1 TO 6
        PRINT "Il repassera par là"
    NEXT second
END

Ici, il y aura quinze écritures consécutives de « il est passé par ici », puis six écritures consécutives de « il repassera par là », et ce sera tout.

Des boucles peuvent donc être imbriquées (cas n°1) ou successives (cas n°2). Cependant, elles ne peuvent jamais, au grand jamais, être croisées. Cela n’aurait aucun sens logique, et de plus, bien peu de langages vous autoriseraient ne serait-ce qu’à écrire cette structure aberrante.

ALGORITHM impossible
VARIABLE
    one, second : NUMBER
BEGIN
    FOR one ←1 TO 10
        [instructions]
        FOR second ← 1 TO 10
            [instructions]
    NEXT one
        [instructions]
        NEXT second
END

Pourquoi imbriquer des boucles ? Pour la même raison qu’on imbrique des tests. La traduction en bon français d’un test, c’est un « cas ». Eh bien un « cas » (par exemple, « est-ce un homme ou une femme ? ») peut très bien se subdiviser en d’autres cas (« a-t-il plus ou moins de 18 ans ? »).

De même, une boucle, c’est un traitement systématique, un examen d’une série d’éléments un par un (par exemple, « prenons tous les employés de l’entreprise un par un »). Eh bien, on peut imaginer que pour chaque élément ainsi considéré (pour chaque employé), on doive procéder à un examen systématique d’autre chose (« prenons chacune des commandes que cet employé a traitées »). Voilà un exemple typique de boucles imbriquées : on devra programmer une boucle principale (celle qui prend les employés un par un) et à l’intérieur, une boucle secondaire (celle qui prend les commandes de cet employé une par une).

Dans la pratique de la programmation, la maîtrise des boucles imbriquées est nécessaire, même si elle n’est pas suffisante.

Examinons l’algorithme suivant :

ALGORITHM wrong
VARIABLE
    Truc : INTEGER
BEGIN
    FOR Truc ← 1 TO 15
        Truc ← Truc * 2
        PRINT "Passage numéro : " + Truc
    NEXT Truc
END

Vous remarquerez que nous faisons ici gérer « en double » la variable Truc, ces deux gestions étant contradictoires. D’une part, la ligne

FOR… augmente la valeur de Truc de 1 à chaque passage. D’autre part la ligne Truc ← Truc * 2 double la valeur de Truc à chaque passage. Il va sans dire que de telles manipulations perturbent complètement le déroulement normal de la boucle, et sont causes, sinon de plantage, tout au moins d’exécutions erratiques.

Il consiste donc à manipuler, au sein d’une boucle FOR, la variable qui sert de compteur à cette boucle. Cette technique est à proscrire absolument… sauf bien sûr, si vous cherchez un prétexte pour régaler tout le monde au bistrot.

Mais dans ce cas, n’ayez aucune inhibition, proposez-le directement, pas besoin de prétexte !

Exercices

Exercice 8

Écrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la table de multiplication de ce nombre, présentée comme suit (cas où l’utilisateur entre le nombre 7) :

Table de 7 :

7 x 1 = 7

7 x 2 = 14

7 x 3 = 21

7 x 10 = 70

Exercice 9

Écrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :

1 + 2 + 3 + 4 + 5 = 15

NB : on souhaite afficher uniquement le résultat, pas la décomposition du calcul.

Exercice 10

Écrire un algorithme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise en-suite quel était le plus grand parmi ces 20 nombres :

Entrez le nombre numéro 1 : 12

Entrez le nombre numéro 2 : 14

etc.

Entrez le nombre numéro 20 : 6

Le plus grand de ces nombres est : 14

Modifiez ensuite l’algorithme pour que le programme affiche de surcroît en quelle position avait été saisie ce nombre :

C’était le nombre numéro 2

Exercice 11

Réécrire l’algorithme précédent, mais cette fois-ci on ne connaît pas d’avance combien l’utilisateur souhaite saisir de nombres. La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro.

Exercice 12

Lire la suite des prix (en euros entiers et terminée par zéro) des achats d’un client. Calculer la somme qu’il doit, lire la somme qu’il paye, et simuler la remise de la monnaie en affichant les textes « 10 Euros », « 5 Euros » et « 1 Euro » autant de fois qu’il y a de coupures de chaque sorte à rendre.

Print Friendly, PDF & Email