Obligement - L'Amiga au maximum

Mardi 14 août 2018 - 21:56  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles en d'autres langues


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Logiciels
 · Jeux
 · Scène démo
 · Divers


Jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


Programmation : AmigaBasic - Les boucles et les sauts
(Article écrit par Michel Descoins et extrait d'Amiga News Tech - septembre 1989)


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"
PRINT
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 !


[Retour en haut] / [Retour aux articles] [Article précédent] / [Article suivant]