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