 |
Vendredi 19 avril 2024 - 09:32 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Chose promise, chose due : le quatrième volet de notre initiation à l'AmigaBasic va nous emmener loin, très loin, au royaume des boucles et des sauts...
Une petite précision s'impose d'emblée : par "boucle", on entend la répétition d'un nombre quelconque d'instructions (plus généralement, de lignes de programme) pendant un certain nombre, prédéfini ou non, de fois. Par "branchement" ou "saut", on entend le fait de "sauter", à l'aide d'instructions appropriées, plusieurs lignes du programme, avec éventuellement retour à la case départ. Ces deux notions pourraient à priori sembler parfaitement distinctes. Elles le sont.
Si on les rapproche ainsi, c'est uniquement parce qu'elles sont souvent utilisées en parallèle, bien que ce ne soit absolument pas obligatoire (heureusement, d'ailleurs). Cela dit, les sauts sont souvent nécessaires, suite à différents tests (voir le mois dernier pour plus de précisions sur les tests), et on n'en fait pas tout un fromage pour autant. Que voulez-vous, ce n'est pas moi qui ai inventé le BASIC, faut faire avec ce qu'on a. L'usage veut que l'on rapproche les boucles des sauts et réciproquement, rapprochons donc.
Boucle-là un peu !
Il convient maintenant de distinguer deux types de boucles. Dans le premier, le programmeur sait à l'avance combien d'itérations sa boucle devra effectuer. Dans le second, il n'en sait rien du tout !
Prenons comme exemple un programme devant afficher tous les nombres entiers compris entre 1 et 1000. En tant que rédacteur du programme, vous savez à l'avance qu'il va vous falloir effectuer 1000 itérations sur l'instruction PRINT, soit une pour chaque nombre à afficher (à moins que vous ne préfériez taper 1000 fois dans votre listing l'instruction PRINT ?). Voici un programme qui fait ça très bien :
|
FOR i=1 TO 1000 PRINT i NEXT i |
Le "traduire" en français donnerait à peu près ceci : pour i compris entre 1 et 1000, afficher i, prochain i (les puristes de l'algorithmie et du pseudo-code vont certainement me haïr s'ils lisent ceci...).
L'instruction "FOR" permet d'utiliser une variable, ici "i", en tant que compteur de boucle. Au début de la boucle, cette variable prend la valeur de départ indiquée juste après le signe "=", ici "1". Le BASIC exécute ensuite toutes les instructions comprises entre le "FOR" et le "NEXT". Quand il rencontre ce dernier, le compteur de boucle est incrémenté (augmenté), les instructions entre "FOR" et "NEXT" à nouveau exécutées, etc., jusqu'à ce que le compteur atteigne la valeur de fin de boucle spécifiée après le "TO", ici "1000". C'est on ne peut plus simple.
Une variante de l'instruction "FOR" consiste à donner un pas à la boucle :
|
FOR i=1 TO 1000 STEP 2 PRINT i NEXT i |
Les plus attentifs auront remarqué qu'on a ajouté, à la suite de la valeur de fin de boucle, l'instruction "STEP", qui signifie littéralement "pas". Si vous exécutez ce programme, seuls les nombres entiers impairs compris entre 1 et 1000 s'afficheront à l'écran. Le "STEP" définit donc l'incrément du compteur de boucle (dans notre exemple, le compteur "i" est incrémenté de 2 à chaque itération de la boucle). Un "STEP" négatif est également possible :
|
FOR i=1000 TO 1 STEP -1 PRINT i NEXT i |
Ainsi qu'un "STEP" réel :
|
FOR i=1 TO 1000 STEP 0.1 PRINT i NEXT i |
Lorsque je dis que "le nombre d'itérations est connu à l'avance", c'est à la fois vrai et faux. Continuons notre exemple des nombres entiers à afficher, mais modifions-le de telle sorte que l'utilisateur puisse entrer le premier nombre à partir duquel il souhaite voir la liste s'afficher :
|
INPUT "Entrez le premier nombre";Premier FOR i=Premier TO 1000 PRINT i NEXT i |
Faisons même encore plus fort : l'utilisateur pourra définir lui-même les bornes de la boucle :
|
INPUT "Entrez le premier nombre";Premier INPUT "Entrez le dernier nombre";Dernier FOR i=Premier TO Dernier PRINT i NEXT i |
En fait, ici, nous ne connaissons ni la valeur de départ de la boucle, ni sa valeur de fin. Il est pourtant possible d'utiliser l'instruction "FOR..." à condition toutefois que "Premier" soit effectivement inférieur à "Dernier" ! Dans le cas contraire, il ne se passerait rien du tout ! Cela dit, un simple test (que je vous laisse le soin d'écrire) permet de régler ce problème.
Second type de boucle, celles dont on ne connaît à priori pas le nombre d'itérations. Un exemple classique est lorsque l'on demande d'entrer un nombre compris entre deux valeurs précises : on ne sait à priori pas combien de fois l'utilisateur va donner une réponse fausse avant de donner la bonne ! On utilise pour ce type de boucle l'instruction "WHILE... WEND" :
|
Nombre=0 WHILE Nombre<1 OR Nombre>100 INPUT "Entrez un nombre entre 1 et 100";Nombre WEND PRINT "Merci" |
Ce programme est une alternative intéressante à celui proposé le mois dernier. Essayons de "traduire" ce programme en français : Nombre=0, tant que Nombre<1 ou Nombre>100, demander Nombre, fin de boucle tant que.
Première constatation, la valeur de la variable "Nombre" doit être connue à l'avance, afin de pouvoir la tester dans la boucle "WHILE". C'est l'objet de la déclaration "Nombre=0". Seconde constatation, ce test de la variable "Nombre" est effectué avant l'instruction "INPUT", alors que dans une boucle "FOR", le test de la valeur de fin de boucle est effectué lorsque le BASIC rencontre l'instruction "NEXT", c'est-à-dire après que le bloc d'instructions entre "FOR" et "NEXT" ait été exécuté. Cette seconde constatation en amène une troisième : si, dans notre déclaration de la variable "Nombre", nous lui avions assigné une valeur comprise entre 1 et 100, le programme n'aurait même pas demandé d'entrer un nombre ! Essayez, vous verrez bien.
A titre d'exercice, regardez bien le test que nous effectuons après l'instruction "WHILE", et essayez de comprendre pourquoi nous avons utilisé "OR" plutôt que "AND" (au besoin, servez-vous du tableau publié le mois dernier...).
Pour résumer, nous pouvons dire que cette boucle exécute toutes les instructions comprises entre le "WHILE" et le "WEND", et ce tant que la condition exprimée est vraie (petit truc mnémotechnique : "WHILE" en anglais signifie "tant que", et "WEND" est la contraction de "WHILE END", soit littéralement "fin de WHILE"). C'est tout bien compris ? Chouette, nous pouvons donc passer aux sauts et branchements.
Le saut terne
Rapidement, nous allons voir le saut le plus simple qui soit en BASIC, l'instruction "GOTO", qui signifie littéralement "aller à". Cette instruction permet de détourner le déroulement normal du programme. Jusqu'ici, nous n'avons vu que des programmes se déroulant linéairement, c'est-à-dire ligne par ligne, tel qu'il a été écrit. L'instruction "GOTO" permet de sauter directement tout un bloc de lignes, aussi bien en avant qu'en arrière.
Prenons encore un exemple, un de plus. Imaginons un menu donnant le choix entre cinq options différentes (lorsque je dis "menu", je n'entends pas, mais alors là pas du tout, un menu déroulant dans le plus pur style Amiga, avec souris et tout et tout) : Menu :
|
PRINT "1 -> Première option" PRINT "2 -> Seconde option" PRINT "3 -> Troisième option" PRINT "4 -> Quatrième option" PRINT "5 -> Cinquième option" INPUT "Votre choix";Choix IF Choix=1 THEN GOTO Option1 IF Choix=2 THEN GOTO Option2 IF Choix=3 THEN GOTO Option3 IF Choix=4 THEN GOTO Option4 IF Choix=5 THEN GOTO Option5 GOTO Menu Option1: ' Ici, on fait plein de choses ... ' Et on retourne au menu GOTO Menu ' Suite du programme ici ' avec les autres options |
Bon, d'accord, ce programme n'est pas un modèle du genre, mais il illustre très bien notre propos. Vous l'avez compris ? Non ? Alors je vous laisse un mois pour y réfléchir... A bientôt !
|
