LES TABLEAUX DE DONNEES
LES TABLEAUX DE DONNEES
LISTE DES MOTS-CLÉS SPÉCIFIQUES.
Métacommande du QBASIC.
$DYNAMIC : indique que les tableaux seront modifiables avec REDIM.
Commandes du QBASIC.
CLEAR : réinitialise toutes les variables et ferme les fichiers ouverts.
COMMON : définit les variables qui pourront être partagées avec d'autres modules externes.
DEF SEG : (obsolète) réserve un espace de mémoire pour l'accès d'une procédure de mémoire.
DIM : déclare un tableau de données, , non redimensionnable, en précisant le type commun à toutes les données.
ERASE : réinitialise les valeurs des tableaux $STATIC et détruit les tableaux $DYNAMIC.
LBOUND() : retourne le plus petit index possible pour la dimension précisée d'un tableau données.
OPTION BASE : définit index du premier item d'un tableau de données à 0, par défaut, ou 1.
REDIM : déclare ou modifie un tableau de données, redimensionnable, en précisant le type commun à toutes les données.
SHARED : définit que la valeur de la variable pourra être lue et/oumodifiée dans SUB ou FUNCTION.
UBOUND() : retourne le plus grand index possible pour la dimension précisée d'un la tableau données.
Commandes du QB64.
_PRESERVE : préserve les valeurs des items d'un tableaux lors de l'utilisation de REDIM.
QU'EST-CE QU'UN TABLEAU DE DONNÉES.
Un tableau de données est une variable qui contient un certain nombre de valeurs, ses éléments ou items.
Avec le QBASIC du QB64, tous les éléments d'un tableau ont le même type de données. Pour affecter, lire ou modifier la valeur d'un item dans un tableau, on le désigne par le nom de la variable représentant le tableau, suivis de sa position, son index, dans le tableau.
La création de tableaux de données sera utile, si vous avez besoin de variables avec des nombres, ou indices, dans leurs noms. Cela rend les tableaux parfaits dans de nombreux cas. Vous pouvez obtenir plusieurs valeurs du même type simplement en faisant référence aux positions des éléments dans un tableau. De plus, vous pouvez avoir des milliers de possibilités en cas de besoin. Les tableaux de données seront aussi utiles pour contenir des données d'image ou de fichier.
CRÉER UN TABLEAU DE DONNÉES.
Dans QB84, tous les tableaux ayant plus de 11 éléments, ou ayant plusieurs dimensions, doivent être déclarés avant leur utilisation.
L'instruction DIM, ou REDIM, doit être utilisée pour déclarer un tableau de données, en indiquant le type commun à toutes ses données et le nombre d'éléments qu'il contiendra avant que le tableau ne soit utilisé. Les tableaux de données QBASIC étaient limités à 32767 éléments, tandis que les tableaux dans QB64 sont limités à 2147483647 éléments sur les systèmes 32 bits, et à 9223372036854775807 éléments sur les systèmes 64 bits.
DIM LST_Scores(25) AS INTEGER
crée un tableau de 26 items de type INTEGER. Le premier item est à l'index, ou indice, 0 et pourra être appelé avec LST_Scores(0). Le deuxième item est à l'index 1, est sera appelé avec LST_Scores(1). Et ainsi de suite jusqu'au dernier item, le 26è, à l'index 25, nommé LST_Scores(25).
Note : Les déclarations DIM LST_Scores%(25) et DIM LST_Scores(25) AS INTERGER sont identiques, mais dans le premier cas, le suffixe % devra être utilisé pour appeler un item. Par exemple : LST_Scores%(17) pour appeler le 18è item au lieu de LST_Scores(17).
Par défaut l'index du premier item d'un tableau est 0. Mais ce comportement peut être modifié avec l'instruction composée OPTION BASE ?. Avant la déclaration de vos tableaux de données, indiquez dans votre script :
- OPTION BASE 0, et l'index du premier item sera 0, valeur par défaut ;
- OPTION BASE 1, et l'index du premier item sera 1.
OPTION BASE 1
DIM LST_Scores(25) AS INTEGER
créé un tableau de 25 items de type INTEGER. Le premier item est à l'index 1 et pourra être appelé avec LST_Scores(1). Le deuxième item est à l'index 2, est sera appelé avec LST_Scores(2). Et ainsi de suite jusqu'au dernier item, le 25è, à l'index 25, nommé LST_Scores(25).
La fonction LBOUND() permet de connaitre l'index du premier item d'une dimension d'un tableau de données, tandis que la fonction UBOUND() retourne l'index de son dernier item.
DIM LST_Durees(60) AS INTEGER
OPTION BASE 1
DIM LST_Scores(25) AS INTEGER
OPTION BASE 0
DIM LST_Restes(12) AS INTEGER
PRINT "Les index des items du tableau LST_Durees vont de"; LBOUND(LST_Durees); "a"; UBOUND((LST_Durees)
PRINT "Les index des items du tableau LST_Scores vont de"; LBOUND(LST_Scores); "a"; UBOUND(LST_Scores)
PRINT "Les index des items du tableau LST_Restes vont de"; LBOUND(LST_Restes); "a"; UBOUND(LST_Restes)
retourne :
Les index des items du tableau LST_Durees vont de 0 a 60
Les index des items du tableau LST_Scores vont de 1 a 25
Les index des items du tableau LST_Restes vont de 0 a 12
Il est aussi possible de choisir la plage d'index, qui sera utilisé pour désigner les items du tableau de données, en indiquant cette plage au moment de la déclaration du tableau. Notez cependant que des index négatifs, surtout s'ils indiquent l'index du dernier item du tableau, pourront provoquez des erreurs lors de l’exécution du programme.
DIM LST_Distances(10 TO 30) AS INTEGER
PRINT "Les index des items du tableau LST_Distances vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)
retourne : Les index des items du tableau LST_Distances vont de 10 a 30
L'adresse du segment de mémoire du tableau peut être définie avec DEF SEG = VARSEG(k(0)) : koffset = VARPTR(k(0)). Et si OPTION BASE 1 est utilisée, remplacez 0 par 1. Le premie index du tableau peut être modifié lorsque d'autres données sont indexées dans le tableau. Cependant, QB64 implémente l'accès à la mémoire à l'aide de _MEM. Pour cette raison, l'usage de DEF SEG et fortement déconseillé, et n'est conservé par QB64 que pour maintenir la compatibilité avec les anciens scripts.
LIRE OU MODIFIER LES DONNÉES D'UN TABLEAU.
Pour lire, ou modifier, la valeur d'un des items d'un tableau de données, il suffit de faire suivre le nom du tableau de données par l'index de l'item, entre parenthèses, avec lequel on souhaite travailler.
DIM LST_Valeurs(20) AS INTEGER
FOR kindex = 0 TO 20: PRINT LST_Valeurs(kindex);: NEXT kindex: REM - lecture des valeurs
FOR kindex = 0 TO 20: LST_Valeurs(kindex) = INT (RND * 800): NEXT kindex: REM - modification des valeurs
FOR kindex = 0 TO 20: PRINT LST_Valeurs(kindex);: NEXT kindex: REM - lecture des valeurs
retourne :
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
564 426 463 231 241 619 11 608 651 567 36 551 990 632 298 760 796 44 759 291 419
Si le mot-clé SHARED est présent dans la déclaration d'un tableau de données, les valeurs de ses items pourront être lues et/ou modifiées dans les procédures et autres fonctions personnalisées. Sinon l’identification du tableau devra être passé comme paramètre lors de l'appel de ces procédures, en prenant garde à la bonne correspondance du type de données.
DIM SHARED LST_Partages(15) AS INTEGER
DIM LST_Bloques(15) AS INTEGER
k = FNC_Valeurs(LST_Bloques())
PRINT "Apres l'affectation de valeurs."
FOR kindex = 0 TO 15: PRINT LST_Partages(kindex);: NEXT kindex
FOR kindex = 0 TO 15: PRINT LST_Bloques(kindex);: NEXT kindex
END
FUNCTION FNC_Valeurs (Q%())
FOR kindex = 0 TO 15:
LST_Partages(kindex) = INT(RND * 800)
Q%(kindex) = INT(RND * 800)
NEXT kindex
END FUNCTION
retourne :
Apres l'affectation de valeurs.
564 231 11 567 890 374 519 638 97 352 481 73 426 225 520 774
28 675 836 153 733 43 945 253 179 527 943 857 427 539 665 841
Si le mot-clé COMMON est présent dans la déclaration d'un tableau de données, les valeurs de ses items pourront être lues et/ou modifiées dans tous les modules appelés par le programme principal. La combinaison COMMON SHARED sera utilisée si l'on souhaite partager les valeurs des items d'un tableau de données avec les sous-modules et les fonctions de ce module.
DIM LST_Scores(15) AS INTEGER
DIM LST_Niveau(15) AS INTEGER
COMMON LST_Scores
COMMON SHARED LST_Niveau
le tableau nommé LST_Scores est partagé avec tous les modules principaux importés avec $INCLUDE et celui qui serait chargé avec CHAIN, tandis que le tableau nommé LST_Niveau est partagé avec tous les modules principaux importés avec $INCLUDE et celui qui serait chargé avec CHAIN, mais aussi avec les fonctions personnalisées qu'ils comportent;
Note : la technique multimodulaire remonte à l'époque où QBASIC avaient des contraintes de taille de module. Ce qui n'est plus le cas avec QB64, COMMON a été conservé à des fins de compatibilité avec des anciens codes. Les contraintes de taille n'existant plus, il est fortement conseillé de rédiger des projets regroupant toutes les fonctionnalités en un seul script, à l'exception d'éventuelles bibliothèques importées par $INCLUDE.
L'instruction CLEAR réinitialise toutes les valeurs des items, de tous les tableaux de données, à 0 pour les types numériques et à une chaine vide pour les STRING. Alors que l'instruction ERASE permet de sélectionner les tableaux de données qui doivent être réinitialisés. Notez que les tableaux déclarés avec l'instruction REDIM ou précédés de $DYNAMIC seront détruit et devront être redéclarée après un CLEAR ou un ERASE.
DIM SHARED LST_Un(15) AS INTEGER
DIM SHARED LST_Deux(15) AS INTEGER
DIM SHARED LST_Trois(15) AS INTEGER
PRINT "Apres l'affectations de valeurs."
FNC_Valeurs
FNC_lecture
CLEAR
PRINT "Apres une instruction CLEAR."
FNC_lecture
FNC_Valeurs
PRINT "Apres l'affectations de nouvelles valeurs."
FNC_lecture
ERASE kdeux
PRINT "Apres une instruction ERASE kdeux."
FNC_lecture
END
SUB FNC_lecture
FOR kindex = 0 TO 15: PRINT LST_Un(kindex);: NEXT kindex
FOR kindex = 0 TO 15: PRINT LST_Deux(kindex);: NEXT kindex
FOR kindex = 0 TO 15: PRINT LST_Trois(kindex);: NEXT kindex
END SUB
SUB FNC_Valeurs
FOR kindex = 0 TO 15:
LST_Un(kindex) = INT(RND * 800)
LST_Deux(kindex) = INT(RND * 800)
LST_Trois(kindex) = INT(RND * 800)
NEXT kindex
END SUB
retourne :
Apres l'affectations de valeurs.
564 231 11 567 890 374 519 638 97 352 481 73 426 225 520 774
28 675 836 153 733 43 945 253 179 527 943 857 427 539 665 841
684 639 833 984 327 749 353 66 835 630 704 63 974 427 532 6
Apres une instruction CLEAR.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Apres l'affectations de nouvelles valeurs.
634 953 76 536 884 543 893 65 386 532 905 54 734 957 323 665
63 730 633 294 412 83 9 342 947 552 673 772 103 28 519 631
982 658 720 199 875 284 620 538 517 843 368 472 745 49 876 174
Apres une instruction ERASE kdeux.
634 953 76 536 884 543 893 65 386 532 905 54 734 957 323 665
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
982 658 720 199 875 284 620 538 517 843 368 472 745 49 876 174
Des tableaux de données peuvent être déclarés dans des procédures personnalisées, FUNCTION ou SUB. De plus, le mot-clé SHARED, sans l'instruction DIM, peut être utilisé à l'intérieur d'une procédure personnalisée, pour exporter les valeurs des variables avec le programme principal, mais pas avec les autres procédures personnalisées. Bientot, QB64 permettra ce partage avec d'autres procédures.
Dans les procédures personnalisées, les tableaux peuvent être définis comme STATIC pour préserver les valeurs de leurs items à la sortie de la procédure pour une utilisation future. Ces valeurs seront conservées jusqu'à ce qu'elles soient modifiées à l'intérieur de cette procédure.
FNC_Demi: END
SUB FNC_Demi
STATIC kindex%, LST_Gardes(12) AS DOUBLE
DIM LST_Perdus(12) AS DOUBLE
IF kindex% = 0 THEN LST_Gardes(0) = 1000 ELSE LST_Gardes(kindex%) = LST_Gardes(kindex% - 1) / 2
LST_Perdus(kindex%) = LST_Gardes(kindex%)
PRINT "A l'index :"; kindex%; " GARDE :";
FOR kvaleur = 0 TO 4: PRINT LST_Gardes(kvaleur);: NEXT kvaleur
PRINT " ET PERDU :";
FOR kvaleur = 0 TO 4: PRINT LST_Perdus(kvaleur);: NEXT kvaleur
kindex% = kindex% + 1
IF kindex% < 4 THEN FNC_Demi
END SUB
retourne :
A l'index 0 GARDE : 1000 0 0 0 0 ET PERDU : 1000 0 0 0 0
A l'index 1 GARDE : 1000 500 0 0 0 ET PERDU : 0 500 0 0 0
A l'index 2 GARDE : 1000 500 250 0 0 ET PERDU : 0 0 250 0 0
A l'index 3 GARDE : 1000 500 250 125 0 ET PERDU : 0 0 0 125 0
Les données du tableau LST_Gardes() et la valeur de kindex% sont conservées entre deux appels de la fonction personnalisée FNC_Demi alors que celles du tableau LST_Perdus() sont détruites.
REDIMENSIONNER UN TABLEAU DE DONNÉES.
Par défaut, les tableaux de données sont $STATIC, c'est-à-dire que leur nombre d'items ne peut pas être modifié, à moins que la métacommande $DYNAMIC ne soit indiqué en début de script. Pour modifier le nombre d'items d'un tableau de données, on utilisera l'instruction REDIM. Si un tableau de données n'est pas modifiable, une erreur pourra interrompre le programme si REDIM est utilisé pour ce tableau de données.
DIM LST_Durees(60) AS INTEGER
REM $DYNAMIC
DIM LST_Scores(25) AS INTEGER
PRINt "Avant de redimensionner les tableaux : "
PRINT "Les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)
PRINT "Les index des items du tableau kscore vont de"; LBOUND(LST_Scores); "a"; UBOUND(LST_Scores)
REDIM LST_Durees(180) AS INTEGER
REDIM LST_Scores(12) AS INTEGER
PRINt "Apres de redimensionner les tableaux : "
PRINT "Les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)
PRINT "Les index des items du tableau kscore vont de"; LBOUND(LST_Scores); "a"; UBOUND(LST_Scores)
retourne :
Avant de redimensionner les tableaux :
Les index des items du tableau kduree vont de 0 a 60
Les index des items du tableau kscore vont de 1 a 25
Apres de redimensionner les tableaux :
Les index des items du tableau kduree vont de 0 a 60
Les index des items du tableau kscore vont de 1 a 12
Note : les métacommandes de QBASIC doivent être précédées de l'instruction REM, ou d'une apostrophe (').
Il est possible de déclarer un tableau de données, directement avec l'instruction REDIM. Dans ce cas, il pourra être redimensionné sans utiliser la métacommande $DYNAMIC.
REDIM LST_Durees(60) AS INTEGER
PRINT "Avant de redimensionnement : ";
PRINT "les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)
REDIM LST_Durees(180) AS INTEGER
PRINT "Apres de redimensionnement : ";
PRINT "les index des items du tableau kduree vont de"; LBOUND(LST_Durees); "a"; UBOUND(LST_Durees)
retourne :
Avant de redimensionnement : les index des items du tableau kduree vont de 0 a 60
Apres de redimensionnement : les index des items du tableau kduree vont de 0 a 180
L'instruction REDIM permet aussi de modifier la plage d'index des items, en changeant ou non le nombre d'items, d'un tableau de données.
REDIM LST_Distances(10 TO 30) AS INTEGER
PRINT "A. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)
REDIM LST_Distances(50 TO 70) AS INTEGER
PRINT "B. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)
REDIM LST_Distances(5 TO 10) AS INTEGER
PRINT "C. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)
REDIM LST_Distances(37 TO 74) AS INTEGER
PRINT "D. Les index des items du tableau kdistance vont de"; LBOUND(LST_Distances); "a"; UBOUND(LST_Distances)
retourne :
A. Les index des items du tableau kdistance vont de 10 a 30
B. Les index des items du tableau kdistance vont de 50 a 70
C. Les index des items du tableau kdistance vont de 5 a 10
D. Les index des items du tableau kdistance vont de 37 a 74
Lors d'un redimensionnement d'un tableau de données, toutes les valeurs des items sont réinitialisées à leur valeur par défaut : 0 pour les valeurs numériques ou une chaine vide pour les STRING. Cela est particulièrement utile pour réinitialiser toutes les valeurs des données du tableau. Cependant, le QB64 a ajouté l'instruction _PRESERVE permettant de conserver les valeurs des items lors du redimensionnement d'un tableau. L'instruction _PRESERVE doit être placée avant le mot-clé SHARED, s'il est utilisé, dans la nouvelle déclaration du tableau de données.
REDIM LST_Durees(60) AS INTEGER
REDIM LST_Scores(15) AS INTEGER
REDIM LST_Cotes(15) AS INTEGER
FOR kvaleur = 0 TO 60 : LST_Durees(kvaleur) = 60 - kvaleur : NEXT kvaleur
FOR kvaleur = 0 TO 15 : LST_Scores(kvaleur) = RND * 100 : NEXT kvaleur
FOR kvaleur = 0 TO 15 : LST_Cotes(kvaleur) = RND * 10 : NEXT kvaleur
PRINT "Avant de redimensionner les tableaux : "
FOR kvaleur = 0 TO 5 : PRINT kvaleur, LST_Durees(kvaleur), LST_Scores(kvaleur), LST_Cotes(kvaleur) : NEXT kvaleur
REDIM _PRESERVE LST_Durees(30) AS INTEGER
REDIM LST_Scores(25) AS INTEGER
REDIM LST_Cotes(15) AS INTEGER
PRINT "Apres de redimensionner les tableaux : "
FOR kvaleur = 0 TO 5 : PRINT kvaleur, LST_Durees(kvaleur), LST_Scores(kvaleur), LST_Cotes(kvaleur) : NEXT kvaleur
retourne :
Avant de redimensionner les tableaux :
0 60 71 7
1 59 53 3
2 58 17 1
3 57 84 7
4 56 47 5
5 55 29 8
Apres de redimensionner les tableaux :
0 60 0 0
1 59 0 0
2 58 0 0
3 57 0 0
4 56 0 0
5 55 0 0
Si la plage d'index d'un tableau de données et modifiée par une instruction REDIM, la présence de l'instruction _PRESERVE conservera les valeurs de ses items et, de plus, les placera avec les nouveaux index dans le même ordre que précédemment.
REDIM SHARED LST_Valeurs(12) AS INTEGER
FOR kindex = 0 TO 12: LST_Valeurs(kindex) = kindex: NEXT kindex
FNC_Afficher
REDIM _PRESERVE LST_Valeurs(30 TO 42) AS INTEGER
FNC_Afficher
REDIM _PRESERVE LST_Valeurs(20 TO 27) AS INTEGER
FNC_Afficher
REDIM _PRESERVE LST_Valeurs(10 TO 28) AS INTEGER
FNC_Afficher
REDIM LST_Valeurs(7 TO 22) AS INTEGER
FNC_Afficher
END
SUB FNC_Afficher
kdebut% = LBOUND(LST_Valeurs)
kfin% = UBOUND(LST_Valeurs)
FOR kindex = kdebut% TO kfin%: PRINT LST_Valeurs(kindex);: NEXT kindex
END SUB
retourne :
0 1 2 3 4 5 6 7 8 9 10 11 12
0 1 2 3 4 5 6 7 8 9 10 11 12
0 1 2 3 4 5 6 7
0 1 2 3 4 5 6 7 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
LES TABLEAUX DE DONNÉES A PLUSIEURS DIMENSIONS.
Un tableau de données peut être créé avec une, deux, ou plusieurs dimensions. Pour cela, il suffit, dans la déclaration du tableau de données, de séparer le nombre d'items de chaque dimension par une virgule. Le QBASIC accepté jusqu'à 60 dimensions pour les tableaux de données. Le QB64 accepte autant de dimensions que nécessaire, tant que la mémoire de la machine n'est pas saturée.
DIM LST_Coordonnees(17, 8) AS SINGLE
crée un tableau à 2 dimensions. La première dimension contient 18 items et la deuxième dimension 9 items.
DIM LST_3d(23, 14, 37) AS STRING
crée un tableau à 3 dimensions. La première dimension contient 24 items, la deuxième dimension 15 items et la troisième dimension 38 items.
Lors de la création d'un tableau de données multidimension, il est possible de préciser la plage d'index de chacune des dimensions, en séparant chaque plage d'index par une virgule.
DIM LST_Lances(8 TO 27, 14 TO 32, 172 TO 204, 31 TO 50) AS DOUBLE
crée un tableau à 4 dimensions. les index des items vont :
- de 8 à 27 pour la première dimension, soit 20 items ;
- de 14 à 32 pour la deuxième dimension, soit 19 items ;
- de 172 à 204 pour la troisième dimension, soit 33 items ;
- de 31 à 50 pour la quatrième dimension, soit 20 items.
Les instructions et mots-clés présentés précédemment, pour les tableaux de données simples, peuvent être utilisés pour les tableaux de données à plusieurs dimensions, à condition de préciser à quelle dimension il faut l'appliquer.
DIM LST_Lances(8 TO 27, 14 TO 32, 172 TO 204, 31 TO 50 ) AS DOUBLE
PRINT "Les index de la premiere dimension de"; LBOUND(LST_Lances, 1); "a"; UBOUND(LST_Lances, 1)
PRINT "Les index de la deuxieme dimension de"; LBOUND(LST_Lances, 2); "a"; UBOUND(LST_Lances, 2)
PRINT "Les index de la troisieme dimension de"; LBOUND(LST_Lances, 3); "a"; UBOUND(LST_Lances, 3)
PRINT "Les index de la quatrieme dimension de"; LBOUND(LST_Lances, 4); "a"; UBOUND(LST_Lances, 4)
retourne :
Les index de la première dimension de 8 a 27
Les index de la deuxième dimension de 14 a 32
Les index de la troisième dimension de 172 a 204
Les index de la quatrième dimension de 31 a 50
Note : Il est bien entendu possible de modifier le nombre d'items de chaque dimension d'un tableau de données $DYNAMIC ou déclaré avec l'instruction REDIM, de changer leur plage d'index, et de conserver les valeurs des items lors de ces opérations avec _PRESERVE, mais il n'est pas possible de modifier le nombre de dimensions d'un tableau de données.
.
SAUVEGARDER ET RESTITUER LES DONNÉES D'UN TABLEAU.
A la fin du programme, les valeurs des items des tableaux de données sont détruites. Si ces valeurs sont des valeurs connues et immuables au départ du programme, elles peuvent être intégrées au script avec des instructions DATA, READ et RESTORE. Mais si ces valeurs sont modifiées durant l'exécution de l'applications et qu'elles doivent être restituées au prochain lancement du programme, il faudra prévoir de les sauvegarder dans un fichier.
Note : Les fichiers étant principalement des fichiers textes, il faudra penser à convertir les valeurs numériques en STRING pour l'enregistrement, mais surtout de les reconvertir dans le bon type numérique lors de l'acquisition des valeurs. Par exemple :
REM --- Creation d'un tableau avec des valeurs aleatoies ---
DIM LST_Valeurs(20) AS INTEGER
FOR kindex% = 0 TO 20: LST_Valeurs(kindex%) = INT(RND * 800): NEXT kindex%: REM - affecte des valeurs aux items
FOR kindex% = 0 TO 20: PRINT LST_Valeurs(kindex%);: NEXT kindex%: REM - affiche les valeurs pour le controle
REM --- Enregistrement des valeurs du tableau dans un fichier (texte) ---
OPEN "MonFichier.txt" FOR OUTPUT AS #1: REM - ouvre le fichier texte en ecriture
FOR kindex% = LBOUND(LST_Valeurs) TO UBOUND(LST_Valeurs): REM - créer un boucle pour tous les index
kvaleur$ = STR$(LST_Valeurs(kindex%)): REM - créer un boucle pour tous les index
PRINT #1, kvaleur$: REM - ecrit la valeur dans le fichier en derniere position
NEXT kindex%
CLOSE #1: REM - IMPORTANT - ferme le fichier
REM --- RaZ des valeurs (pour controle) ---
CLEAR: REM - réinitialise les valeurs des items à 0
FOR kindex% = 0 TO 20: PRINT LST_Valeurs(kindex%);: NEXT kindex%: REM - controle de la réinitialisation
REM --- Lecture et conversion des valeurs du tableau depuis un fichier ---
OPEN "MonFichier.txt" FOR INPUT AS #1: REM - ouvre le fichier texte en lecture
kindex% = LBOUND(LST_Valeurs): REM - initialise la valeur du premier index du tableau de donnees
DO UNTIL EOF(1): REM - creer une boucle tant que la fin du fichier n'est pas atteinte
INPUT #1, kvaleur$: REM - lecture (recuperation) de l’enregistrement suivant
kvaleur% = VAL(kvaleur$): REM - reconvertie la valeur dans le bon type numérique
LST_Valeurs(kindex%) = kvaleur%: REM - affecte l'item de l'index correspondant avec la valeur
kindex%= kindex% + 1: REM - augmente la valeur de l'index de 1
LOOP
CLOSE #1: REM - IMPORTANT - ferme le fichier
REM --- Affichage pour controle ---
FOR kindex% = 0 TO 20: PRINT LST_Valeurs(kindex%);: NEXT kindex%: REM - controle de la bonne restitution
retourne :
564 426 463 231 241 619 11 608 651 567 36 551 990 632 298 760 796 44 759 291 419
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
564 426 463 231 241 619 11 608 651 567 36 551 990 632 298 760 796 44 759 291 419
TABLEAU DE DONNÉES AVEC DES TYPES DIFFÉRENTS.
Les items d'un tableau de données doivent tous être du même type. En théorie, il n'est donc pas possible de trouver des valeurs de types différents numériques, voire des STRING, dans les données d'un même tableau. Cependant, pour palier à cette contrainte, il suffit de définir un type personnalisé de données avant de déclarer le tableau et d'utiliser ce nouveau type personnalisé comme type pour les données du tableau. Par exemple :
REM --- Tableau de joueurs avec un type personnalise ---
TYPE DCT_Joueur
id AS INTEGER
pseudo AS STRING
force AS INTEGER
sante AS SINGLE
outil AS STRING
coordonnees AS STRING * 7
score AS SINGLE
END TYPE
OPTION BASE 1
DIM LST_joueurs(20) AS DCT_Joueur
LST_joueurs(1).id = 100
LST_joueurs(1).pseudo = "Origine"
LST_joueurs(1).force = 100
LST_joueurs(1).sante = 100.00
LST_joueurs(1).outil = "ordinateur"
LST_joueurs(1).coordonnees = "50:50"
LST_joueurs(1).score = 0.00
PRINT LST_joueurs(1).id
PRINT LST_joueurs(1).pseudo
PRINT LST_joueurs(1).force
PRINT LST_joueurs(1).sante
PRINT LST_joueurs(1).outil
PRINT LST_joueurs(1).coordonnees
PRINT LST_joueurs(1).score
REM --- Gestion des joueurs avec plusieurs tableaux ---
OPTION BASE 1
DIM LST_Id(20) AS INTEGER
DIM LST_Pseudo(20) AS STRING
DIM LST_Force(20) AS INTEGER
DIM LST_Sante(20) AS SINGLE
DIM LST_Outil(20) AS STRING
DIM LST_Coordonnees(20) AS STRING * 7
DIM LST_Score(20) AS SINGLE
LST_Id(1).id = 100
LST_Pseudo(1) = "Origine"
LST_Force(1) = 100
LST_Sante(1) = 100.00
LST_Outil(1) = "ordinateur"
LST_Coordonnees(1) = "50:50"
LST_Score(1) = 0.00
PRINT LST_Id(1)
PRINT LST_Pseudo(1)
PRINT LST_Force(1)
PRINT LST_Sante(1)
PRINT LST_Outil(1)
PRINT LST_Coordonnees(1)
PRINT LST_Score(1)
Votre aide est précieuse pour améliorer ce site, alors n'hésitez pas à faire part de
Dans la RETROGICIEL vous trouvez des suggestions simples et classiques pour
TESTER - DÉCOUVRIR - PRATIQUER - APPROFONDIR - EXPLORER
avec un exemple de résolution à télécharger pour vous inspirer.