<< Retour au sommaire

 

Les boucles

 

 

 

Le sommaire :

1.      Qu’est-ce que c’est ?

2.      La boucle Repeat ;

3.      La boucle While ;

4.      La boucle For ;

5.      La boucle imbriquée ;

6.      Break & End, des instructions de boucles.

 

 

Qu’est-ce que c’est ?

 

Une boucle est une structure qui exécute un traitement tant qu’une condition est vraie, ou jusqu’à ce qu’une condition soit vraie, tout dépend du type de la boucle utilisée.

 

Une boucle est dite aussi une « répétitive ».

 

Le traitement qui est exécuté dans la boucle est dit le « corps de la boucle ».

Une exécution du corps de la boucle est dite une « itération ».

 

La boucle Repeat

 

La syntaxe :

Repeat

 Traitement

Until condition

 

La description

Traitement est répété jusqu’à ce que condition soit vraie.

 

Pour commencer, le traitement est exécuté au moins une fois, puis la condition est vérifiée :

1.      Si la condition est fausse, le traitement est ré exécuté et ainsi de suite ;

2.      Si enfin la condition est vraie, la boucle est stoppée.

 

Remarque :

 

Dans l’exemple qui suit, le corps de la boucle propose à l’utilisateur de sortir. Tant que ce dernier répond « non », la boucle boucle

 

1.      OpenConsole ()

2.      Repeat

3.      ; traitement du corps de la boucle

4.      Print ("Voulez-vous sortir de la boucle ? oui/non ")

5.      Affirmation$ = Input ()

6.      Until Affirmation$="oui"

 

Télécharger le fichier exemple, Source18.pb >>

 


La boucle While

 

Voici les 2 différences entre la boucle Repeat et la boucle While :

  1. Le corps de la boucle Repeat est exécuté au moins une fois, ce qui n’est pas le cas avec la boucle While puisse que la vérification de la condition est réalisée dès le début ;
  2. La question posée au niveau de la condition est inversée.

 

En effet, dans le cas de la boucle Repeat, le sens de la question était :

Répète le traitement jusqu’à ce que la condition soit vraie ;

 

Dans le cas de la boucle While, le sens de la question est :                                                                   

Tant que la condition est vraie, répète le traitement ;

 

Voilà, tout est dit, en résumant, pour que la boucle Repeat tourne, il faut que la condition soit fausse, tandis qu’il faut qu’elle soit vraie pour que la boucle While tourne. Et pour cette dernière, comme la vérification est faite dès la première ligne de la boucle, il suffit que la condition soit fausse dès le début pour que l’exécution du programme ignore et contourne le bloc tout entier de la boucle…

 

En reprenant le même exemple que la boucle « Repeat », voici maintenant la version « While » !

 

  1. OpenConsole ()
  2. PrintN ("Avez-vous le courage d'introduire la boucle ? oui/non ")
  3. Affirmation$ =Input ()
  4. If Affirmation$ = "oui" ; Vérifie si l'utilisateur a confirmé
  5. ; L'utilisateur a confirmé, initialisation de la variable compteur
  6. NB_Iteration =0
  7. EndIf
  8. While Affirmation$ ="oui"
  9. ; traitement du corps de la boucle
  10. NB_Iteration = NB_Iteration+1 ; Incrémentation du compteur d'itérations
  11. Print ("Voulez-vous faire un tour de plus dans la boucle ? oui/non ")
  12. Affirmation$ = Input ()
  13. Wend
  14. If NB_Iteration >= 1  ; Vérifie si l'utilisateur a réalisé au moins une itération
  15. ; C'est un utilisateur courageux, affichage du nombre d'itérations réalisées
  16. PrintN ("Vous avez "+Str(NB_Iteration)+" iterations a votre compteur !")
  17. Else
  18. ; L'utilisateur est une poule mouillée, affichage d'un message un peu hypocrite
  19. PrintN ("Oh vous ferez mieux la prochaine fois !")
  20. EndIf
  21. Print ("Pressez la touche Entree pour continuer...")
  22. Input ()

 

Télécharger le fichier exemple, Source19.pb >>

 


La boucle For

 

Cette boucle est très différente des 2 autres…

En quoi est-elle si différentes ?

-         Eh bien, cette fois le nombre d’itérations est fixé à l’avance…

 

La syntaxe :

For compteur = valeur-de-départ To valeur_de_fin Step Valeur_incrémentation

Traitement

Next

 

La description:

 

Compteur est une variable de type entier, elle représente le compteur de la boucle, elle est dite « indice ».

 

Valeur_de_départ est un entier, il représente la valeur de départ de l’indice.

Valeur_de_fin est un entier, il représente la valeur de fin de l’indice.

 

L’indice va donc prendre la première valeur pour débuter le manège et va successivement, d’itération en itération, prendre les entiers qu’implique l’intervalle de valeur_de_départ et valeur_de_fin.

 

Par exemple :

For I = 1 To 5

Première itération, l’indice I aura la valeur 1 ;

Deuxième itération, l’indice I aura la valeur 2 ;

Troisième itération, l’indice I aura la valeur 3 ;

Quatrième itération, l’indice I aura la valeur 4 ;

Cinquième itération, l’indice I aura la valeur 5 ;

Stop, la boucle est finie…

 

Quant au mot clé « Step », « pas » en français, il donne la valeur d’incrémentation du pas.

Lorsque cette information est omise, le Step par défaut est 1, l’indice va donc s’incrémenter de 1 en 1

 

Tenez, en reprenant l’exercice du haut, mais cette fois avec un pas de 2, voici ce que ça donne :

For I = 1 To 5

Première itération, l’indice I aura la valeur 1 ;

Deuxième itération, l’indice I aura la valeur 3 ;

Troisième itération, l’indice I aura la valeur 5 ;

Stop, la boucle est finie…

 

Next est le mot clé qui indique la fin du corps de la boucle.

 

Bon, il est temps de passer aux choses sérieuses, voici un exemple et je vous laisse le soin de comprendre vous-mêmes le but de la manoeuvre!

 

  1. OpenConsole ()
  2. PrintN ("Quel nombre entier voulez-vous multiplier ? ")
  3. Multiplicateur$ =Input ()
  4. PrintN ("Table de multiplication de "+Multiplicateur$) ; Affichage du titre avant le développement de la multiplication
  5. For I =1 To 10 Step 1
  6. Produit = I * Val(Multiplicateur$) ; Calcul du produit
  7. PrintN (Multiplicateur$+" fois "+Str(I)+" Egal "+Str(Produit))
  8. Next
  9. Print ("Pressez la touche Entree pour continuer...")
  10. Input ()

 

Télécharger le fichier exemple, Source20.pb >>

 


La boucle imbriquée

 

Lorsque vous imbriquez une boucle dans une autre boucle, la boucle imbriquée fait partie intégrante du corps de la boucle principale, au même titre que toutes les instructions de ce traitement.

Du coup, Pour une itération de la boucle principale, la boucle imbriquée est entièrement exécutée…

 

Voici un exemple relativement clair, construisons la table de multiplications de 1 à 10, ça vous chante ?

 

  1. OpenConsole ()
  2. PrintN ("Les tables de multiplications")
  3. For i=1 To 10
  4. ; La boucle qui va incrémenter I, le multiplicateur
  5. PrintN ("La table de multiplications de "+Str(i))
  6. For j=1 To 10
  7. ; La boucle qui va incrémenter J, le multiplicande
  8. Produit = i*j ; Calcul du produit
  9. PrintN (Str(i)+" fois "+Str(j)+" Egal "+Str(Produit))
  10. Next ; Fin de la boucle imbriquée
  11. Next ; Fin de la boucle principale
  12. Print ("Pressez la touche Entree pour continuer...")
  13. Input ()

 

Télécharger le fichier exemple, Source21.pb >>

 


Break & End, des instructions de boucles

 

  1. A l’intérieur du corps d’une boucle, l’instruction Break arrête l’exécution de la boucle et passe à la suite de l’exécution du programme ;
  2. A l’intérieur du corps d’une boucle, l’instruction End interrompe carrément l’exécution du programme.

 

En reprenant l’exercice de la boucle « Repeat », j’ai inséré 2 nouveaux traitements, à vous de juger…

 

  1. OpenConsole ()
  2. Repeat
  3. ; traitement du corps de la boucle
  4. Print ("Voulez-vous sortir de la boucle ? oui/non ")
  5. Affirmation$ = Input ()
  6. ; Vérifie si l'utilisateur a envoyé un SOS
  7. If Affirmation$ ="sos"
  8. End
  9. EndIf
  10. ; Vérifie si l'utilisateur a pris la prote de secours
  11. If Affirmation$="secours"
  12. Break
  13. EndIf
  14. Until Affirmation$="oui"
  15. PrintN ("L'exercice est fini !")
  16. Print ("Pressez la touche Entree pour continuer...")
  17. Input ()

 

Télécharger le fichier exemple, Source22.pb >>

 

Philippe BOULANGER