Suivez-nous sur X
|
|
|
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,
ALL
|
|
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
|
|
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
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Amiga E - structure de contrôle
(Article écrit par Yann Armand et extrait d'Amiga News - juillet 1995)
|
|
Attachons-nous à ce qui sans quoi la programmation sous quelque langage que ce soit n'existerait pas. Plus simplement, apprenons
à notre programme à se poser des questions et à ordonner ses traitements.
Il existe deux types de structures de contrôle : les conditions et les boucles. Les premières autorisent ou non l'exécution de
traitements sous certaine(s) condition(s), alors que les secondes permettent l'exécution répétitive de traitements.
Mettons-nous tout de suite d'accord sur la façon de présenter la syntaxe de ces structures.
<exp> représentera une expression, par exemple a<2 (a inférieur à 2).
<inst> représentera une instruction, par exemple WriteF('bonjour') (écrit bonjour).
Les conditions
Commençons par les conditions simples.
IF <exp 1> THEN <inst 1> [ELSE <inst 2>]
|
Si <exp 1> est vraie alors on exécute <inst 1> sinon on exécute <inst 2>. La partie ELSE (sinon) est facultative.
En fait, dire que <exp 1> est vraie revient à dire qu'elle est non nulle. Ainsi pour l'expression IF intuitionbase THEN ...
si intuitionbase ne contient pas 0, on exécute la condition.
Il arrivera souvent que nous ayons un traitement en plusieurs instructions. La syntaxe sera alors :
IF <exp 1>
<inst>
...
<inst>
[ ELSE
<inst>
...
<inst> ]
ENDIF
|
Mais comment fait-on quand un choix présente plus de deux alternatives, me demanderez-vous ? On utilise l'instruction ELSEIF.
Un exemple ?
IF a<2
WriteF('a est inférieur à 2')
ELSEIF 2<a AND a<5
WriteF('a est compris entre 2 et 5')
ELSEIF 5<a
WriteF('a est supérieur à 5')
ELSE
WriteF('a=2 ou a=5')
ENDIF
|
Il existe un cas particulier pour les prises de décision à choix multiples.
Quand nous voudrons évaluer si la valeur d'une expression fait partie d'un certain nombre de constantes, nous utiliserons la
structure SELECT :
SELECT leon
CASE 1
WriteF('leon a 1 cochon')
CASE 2
WriteF('leon a 2 cochons')
CASE 3
WriteF('leon a 3 cochons')
DEFAULT
WriteF('leon a plus de 3 cochons')
ENDSELECT
|
On évalue la variable leon. Si elle est égale à 1 on écrit "leon a 1 cochon", etc. Et par défaut (dans tous les autres cas on
écrit "leon a plus de 3 cochons"). En fait, la structure SELECT est équivalante à une série de IF/ELSEIF.
Les boucles conditionnelles
WHILE <exp> DO <inst> ou
WHILE <exp>
<inst>
...
<inst>
ENDWHILE
|
<exp> est évaluée. Si elle est vraie (non nulle) on exécute l'(es) instruction(s) et on évalue de nouveau <exp>.
Ainsi de suite tant que <exp> est vraie.
REPEAT
<inst>
...
<inst>
UNTIL
|
Le fonctionnement est le même que pour la boucle WHILE sauf que l'on commence par exécuter les instructions avant d'évaluer <exp>.
On utilisera WHILE quand <exp> peut être fausse avant le traitement, et REPEAT/UNTIL lorsque le traitement doit être effectué
au moins une fois. Nous pouvons briser une boucle WHILE si au cours du traitement une condition devient vraie en utilisant :
Par exemple :
Si le n-ième caractère de chaîne est nulle, on sort de la boucle.
Ceci peut être pratique pour optimiser notre source. En effet, il est parfois inutile de continuer la boucle jusqu'à la fin.
La boucle de comptage
FOR <var>:=<exp1> TO <exp2> STEP <pas>
<inst>
...
<inst>
ENDFOR
|
La variable <var> reçoit la valeur <exp1>. A chaque fois que le traitement sera effectué, elle sera incrémentée du <pas>
jusqu'à atteindre la valeur <exp2>, alors on sortira de la boucle. La boucle FOR peut aussi être brisée par EXIT.
La boucle infinie
LOOP
<inst>
...
<inst>
ENDLOOP
|
LOOP est une boucle qui tourne à l'infini et on ne peut en sortir que par un RETURN qui achèvera le traitement de la procédure en cours.
Les étiquettes de branchement
Le E nous permet de poser des étiquettes le long de notre source. Celles-ci seront des repères auxquels nous pourront sauter grâce
à l'instruction :
Ceci pourra nous être utile par exemple pour sortir directement d'une structure de contrôle à plusieurs niveaux. Et comme un
exemple vaut mieux qu'un long discours :
FOR .....
WHILE ....
......
IF (catastrophe) THEN JUMP erreur
......
ENDWHILE
ENDFOR
.....
erreur:
<réparation des erreurs>
|
Si au cours du traitement de ces deux boucles imbriquées, une catastrophe survient, nous sautons à l'étiquette erreur : qui est
suivie du traitement des erreurs.
Il est néanmoins à noter qu'il est facile d'abuser de l'instruction JUMP et de rendre notre source illisible. Imaginez que par
erreur l'utilisation de JUMP vous fasse sortir du corps d'une de vos procédures. Le programme va probablement se planter et
vous mettrez un bon moment à trouver l'erreur dans la source.
L'utilisation de JUMP n'est jamais obligatoire et on peut toujours se débrouiller autrement.
Pour finir
Ouf !... fini avec la théorie, j'espère que l'indigestion ne sera pas trop douloureuse. Promis, le mois prochain nous commençons
à nous intéresser au système de notre bonne machine puisque le E est fait pour ça.
|
