Obligement - L'Amiga au maximum

Vendredi 26 mai 2017 - 00:02  

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


Soutien

N'hésitez pas à soutenir le projet Obligement



Contact

David Brunet

Courriel

 


Programmation : Amiga E - les listes
(Article écrit par Pierre Girard et extrait d'Amiga News - juin 1996)


Ce mois-ci nous allons nous enfoncer un peu plus loin dans les arcanes du E avec l'étude de fonctions dont on ne se sert pas tous les jours : les listes. Elles peuvent rendre de grands services mais il faut se méfier de quelques points inhérents à leur structure même.

Qu'est ce qu'une liste ?

C'est simple, ce mot recouvre exactement la même réalité que celle décrite dans le dictionnaire. Une liste correspond donc à une succession de chiffres (LONG, INT...), de chaînes de caractères, etc. En fait, les listes sont très proches de tableaux de LONG (array of long). On peut les répertorier en deux catégories : les listes immédiates et les listes typées. Ne comptez pas sur moi pour faire le tour de la question. Pour bien maîtriser les listes, il faut les utiliser souvent et il est vrai que les documentations sont souvent succinctes à leur sujet.

Les listes immédiates

Je pense que ce sont celles que le programmeur a le plus de facilité à utiliser. En effet, elles ne font que rendre la vie "plus agréable" et le code source plus lisible. Comme un dessin vaut mieux qu'un long discours (non, je ne vais pas dessiner), voici l'exemple type. Il s'agit de l'utilisation des listes dans les appels de fonctions système, comme nous l'avions vu dans les articles concernant les AppIcons :

AddAppIconA(0, 0, appname, myport, NIL, diskobj, [MTYPE_APPICON, TAG_DONE])

Ici, les données entre crochets représentent une liste de tags, dont la fonction AddAppIconA a besoin. L'autre utilisation permet d'alléger les programmes. Ainsi, qui ne préfère pas écrire liste:=[1,2,3,4] plutôt que :

liste[1]:=1
liste[2]:=2
liste[3]:=3
liste[4]:=4

Les listes typées

Les listes normales ne permettent de stocker que des LONG. Alors comment faire pour les autres types ? Heureusement, est arrivée la liste typée. Il suffit, à la fin de sa déclaration, de spécifier le type après les deux-points.

liste:=[1,2,3,4):INT.

L'intérêt se voit surtout quand il faut créer et initialiser ses propres structures (objects en E). Le type n'est plus LONG ou INT, mais le nom de l'objet. Voici un exemple avec la structure appelée init :

OBJECT init
    a:LONG,b:CHAR,c:INT
ENDOBJECT

Ensuite, taper [1,2,3]:init signifiera que l'on crée une structure de 8 octets, les 4 premiers étant dédiés au LONG (de valeur 1), l'octet suivant est un CHAR de valeur 2, puis un octet de remplissage et les deux derniers octets pour l'INT (valeur 3). Vous le voyez, c'est très pratique, surtout que nous ne sommes pas limités par la taille du tableau. Ainsi [1,2,3,4,5,6,7,8,9]:init crée un tableau de "init" de taille 3.

Les fonctions du E relatives aux listes

Dans ce paragraphe, il ne sera pas question de décrire en détail ces fonctions qui sont expliquées dans la documentation du E et dont nous nous servons dans le petit exemple, mais juste de les citer pour avoir un bref aperçu des possibilité offertes.

Il y a tout d'abord les fonctions de manipulation des listes : ListCopy (listvar, list, num=ALL), ListAdd (listvar, list, num=ALL), ListCmp (list, list, num=ALL), SetList (listvar, newlen).

Puis les fonctions qui renvoient des valeurs utiles : len:=ListLen (list), max:=ListMax (listvar), value:=ListItem(list,index).

Les pièges à éviter

Manipuler les listes présente parfois quelques petits inconvénients. Les listes et les listes typées sont ce que l'on appelle des données statiques (static data), ce qui signifie que l'adresse de ces données est fixe et déterminée au lancement du programme. En conclusion, si vous voulez initialiser plusieurs éléments d'une liste dans une boucle, par exemple, tous les éléments contiendront la même chose. Il faut donc allouer la liste dynamiquement avec NEW. Une autre solution est possible avec l'instruction List() suivie d'une copie de la liste normale dans la nouvelle liste-E grâce à ListCopy().

L'exemple

Je vous propose un petit programme pour mieux voir comment on utilise les listes. Il s'agit d'une petite base de données qui stocke dans deux listes les noms et numéros de téléphone que l'utilisateur a entré au préalable. Le programme gère des listes dynamiques pour ne pas rencontrer le problème vu plus haut (Cf. le Beginner.guide au chapitre "Static Data). Bien sûr, il n'est pas parfait (loin de là), mais libre à vous de gérer les sauvegardes et, par exemple, de rajouter une interface graphique via GadToolsBox (mais modifiez sa gestion des erreurs qui est sommaire).

Voilà, c'est tout pour aujourd'hui. Je ne sais pas ce que vous en pensez, mais il y a dans les listes des choses simples et pratiques, d'autres beaucoup plus ardues à appréhender (listes liées entre elles...) que je n'ai même pas abordées. Digérez bien tout ça et à bientôt.

/* Base de donnée rudimentaire utilisant les listes */

DEF entrees=0,i,result
DEF choix[5]:STRING
DEF temp[80]:STRING
DEF listenom[80]:LIST
DEF listetel[80]:LIST



PROC main()
-> Choix de l'utilisateur
LOOP
    WriteF('Ajouter une entrée(1), Chercher par nom(2), Chercher par téléphone(3), Quitter(4)\n')
    ReadStr(stdout,choix)
    choix:=Val(choix)

        SELECT choix

-> Nouvelle entrée
            CASE 1

            WriteF('Entrez le nom:\n')
            ReadStr(stdout,temp)
            listenom[entrees]:=List(20)
            IF listenom[entrees]<>NIL THEN
            ListCopy(listenom[entrees],temp, ALL)

            WriteF('Entrez le téléphone:\n')
            ReadStr(stdout,temp)
            listetel[entrees]:=List(20)
            IF listetel[entrees]<>NIL THEN
            ListCopy(listetel[entrees],temp, ALL)
            entrees++   

-> Recherche par nom
            CASE 2

            WriteF('Entrez le nom recherché:\n')
            ReadStr(stdout,temp)
            FOR i:=0 TO entrees-1
                result:=StrCmp(ListItem(listenom,i),temp)
                EXIT result
            ENDFOR
            WriteF ('Nom: \s et téléphone: \s\n', ListItem (listenom, i), ListItem (listetel, i))


-> Recherche par téléphone
            CASE 3

            WriteF('Entrez le téléphone recherché:\n')
            ReadStr(stdout,temp)
            FOR i:=0 TO entrees-1
                result:=StrCmp(ListItem(listetel,i),temp)
                EXIT result
            ENDFOR
            WriteF ('Téléphone: \s et Nom: \s\n', ListItem (listetel, i), ListItem (listenom, i))

-> On sort et on affiche tout
            DEFAULT

            FOR i:=0 TO entrees-1
                WriteF ('Noms et Téléphone: \s - \s\n', listenom [i], listetel [i])
            ENDFOR
            JUMP end
        ENDSELECT
ENDLOOP

end:
    DisposeLink(listenom)
    DisposeLink(listetel)
ENDPROC


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