Obligement - L'Amiga au maximum

Mardi 12 décembre 2017 - 03:40  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · 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 in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


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 : 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 :

EXIT <exp>

Par exemple :

EXIT chaîne[i]=0

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 :

JUMP <étiquette>

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.


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