[EN] [IT]
[INFO] [ACQUÉRIR] [PLAN] [RESSOURCES]
CHAPITRE
APPRENDRE À PROGRAMMER AVEC FUTUREBASIC
NOTES

Les matrices

Les tableaux simples
Les tableaux dynamiques
Les tableaux INDEX$
Les tableaux XREF
Les tableaux de champs

Leçon 8 : Les variables ordonnées (les tableaux ou matrices)

Les tableaux simples
Nous avons enfin passé en revue lʼensemble des types de variables dont nous pouvons disposer pour écrire nos programmes. Tous ces types de variables vont nous permettre de résoudre les problèmes variés que nous serons amenés à rencontrer. Cependant, il existe des situations où une meilleure organisation de nos variables nous faciliterait bien la tâche.

Considérez lʼexemple suivant : un professeur a trois élèves auxquels il attribue chaque trimestre une note et il souhaite calculer la moyenne obtenue par chacun des élèves à la fin de lʼannée. On pourrait écrire ceci :

DIM AS DOUBLE
¬
noteTrim1Eleve1,noteTrim2Eleve1,noteTrim3Eleve1,noteTrim4Eleve1
DIM AS DOUBLE ¬
noteTrim1Eleve2,noteTrim2Eleve2,noteTrim3Eleve2,noteTrim4Eleve2
DIM AS DOUBLE ¬
noteTrim1Eleve3,noteTrim2Eleve3,noteTrim3Eleve3,noteTrim4Eleve3

DIM AS DOUBLE
moyenneEleve1,moyenneEleve2,moyenneEleve3

moyenneEleve1 = ¬
(noteTrim1Eleve1+noteTrim2Eleve1+noteTrim3Eleve1+noteTrim4Eleve1)/4
moyenneEleve2 = ¬
(noteTrim1Eleve2+noteTrim2Eleve2+noteTrim3Eleve2+noteTrim4Eleve2)/4
moyenneEleve3 = ¬
(noteTrim1Eleve3+noteTrim2Eleve3+noteTrim3Eleve3+noteTrim4Eleve3)/4


Le code ci-dessus est facilement compréhensible : pour chacun des élèves, le professeur ajoute les notes obtenues aux 4 trimestres puis divise le total obtenu par 4 (le nombre de trimestres) pour en obtenir la moyenne. Bien que correct au niveau de la syntaxe, ce code nʼest pas facile à maintenir (à faire évoluer), à lire et à corriger, imaginez que la classe soit composée de 40 élèves. Fastidieux !

Il serait plus pratique de pouvoir regrouper les variables sous une même bannière et dʼindiquer laquelle des valeurs nous intéresse plus particulièrement à un moment donné, la première, la deuxième, la troisième, etc. Cʼest exactement ce quʼautorisent les tableaux. Les tableaux sont des regroupements de variables de même nature sous un seul et même nom, les éléments individuels sont accédés au moyen dʼun indice. Pour déclarer un tableau, lʼinstruction DIM peut être utilisée en spécifiant le type des éléments qui le composent et leur nombre. Exemple :

DIM moyenne(3) AS DOUBLE

Lʼinstruction ci-dessus déclare un tableau appelé moyenne composé de valeurs en double précision et qui sont au nombre de...4.

Mais, quel est donc cet élément surprise ? Eh oui, il faudra vous y faire, les tableaux débutent à lʼindice 0, si bien que les indices valides pour notre exemple seraient 0, 1, 2 et 3, ce qui nous donne bien 4 éléments au total. Certains BASIC permettaient de régler lʼindice de départ des tableaux soit à 0, soit à 1, mais FutureBASIC^3 ne possède plus cette option. Rappelez-vous donc que les tableaux commencent toujours à lʼindice 0.

Lorsque vous déclarez un tableau comme montré ci-dessus, FutureBASIC réserve tout de suite la mémoire requise pour stocker tous les éléments du tableau. Il faut donc prêter une attention particulière à la valeur utilisée pour lʼindice dans lʼinstruction DIM, elle ne doit être ni inutilement grande, ni trop petite. Sachez que dans cette instruction, la valeur indiquée pour lʼindice maximal ne peut pas être le résultat dʼun calcul, ce doit être une constante numérique littérale ou une constante nommée. Exemple de déclaration avec une constante nommée :

_nbEleves = 3
DIM moyenne(_nbEleves) AS DOUBLE


Dans notre exemple, il serait intéressant de pouvoir regrouper les notes obtenues par les élèves au cours de lʼannée. On pourrait déclarer des tableaux pour chacun des trimestres de la manière suivante :

DIM noteTrimestre1(_nbEleves) AS DOUBLE
DIM noteTrimestre2(_nbEleves) AS DOUBLE
DIM noteTrimestre3(_nbEleves) AS DOUBLE
DIM noteTrimestre4(_nbEleves) AS DOUBLE

Le calcul de la moyenne se présenterait comme ceci :

moyenne(1) = ¬
(noteTrimestre1(1)+noteTrimestre2(1)+noteTrimestre3(1)+noteTrimestre4(1))/4
moyenne(2) = ¬
(noteTrimestre1(2)+noteTrimestre2(2)+noteTrimestre3(2)+noteTrimestre4(2))/4
moyenne(3) = ¬
(noteTrimestre1(3)+noteTrimestre2(3)+noteTrimestre3(3)+noteTrimestre4(3))/4


Nous avons réduit le nombre de noms de variables à mémoriser et à manipuler. Mais, pourquoi ne pas aller plus loin, puisque les notes trimestrielles ont une évidente similitude, il serait judicieux de pouvoir les regrouper au sein dʼun tableau également tout en gardant les notes associées à chacun des élèves. Ceci est possible, car les tableaux ont une particularité : ils peuvent abriter dʼautres tableaux. On obtient cette imbrication en ajoutant ce quʼon appelle une dimension au tableau. Il sʼagit tout simplement dans notre exemple dʼajouter un second indice :

_nbEleves = 3
_nbTrimestres = 4
DIM moyenne(_nbEleves) AS DOUBLE
DIM notes(_nbEleves,_nbTrimestres) AS DOUBLE


Pour accéder à un élément particulier dʼun tel tableau, par exemple la note obtenue par le deuxième élève au cours du troisième trimestre, on pourrait écrire ceci :

noteEleve2Trim3 = notes(2,3)

Les éléments sont toujours accessibles individuellement, mais sont beaucoup mieux organisés. On verra, par la suite lʼutilité dʼune telle organisation.

Notre calcul de moyenne sʼécrirait donc maintenant comme ceci :

moyenne(1) = ( notes(1,1)+notes(1,2)+notes(1,3)+notes(1,4) )/_nbTrimestres
moyenne(2) = ( notes(2,1)+notes(2,2)+notes(2,3)+notes(2,4) )/_nbTrimestres
moyenne(3) = ( notes(3,1)+notes(3,2)+notes(3,3)+notes(3,4) )/_nbTrimestres


Si lʼon observe attentivement les instructions ci-dessus, on sʼaperçoit quʼà lʼexception des indices qui varient, les formules utilisées pour les calculs sont strictement identiques pour le calcul des moyennes. On pourrait aller encore plus loin et éliminer le tableau moyenne en profitant de lʼindice 0 du tableau notes afin de stocker les moyennes calculées pour chacun des élèves :

_nbEleves = 3
_nbTrimestres = 4
DIM notes(_nbEleves,_nbTrimestres) AS DOUBLE
notes(1,0) = ( notes(1,1)+notes(1,2)+notes(1,3)+notes(1,4) )/_nbTrimestres
notes(2,0) = ( notes(2,1)+notes(2,2)+notes(2,3)+notes(2,4) )/_nbTrimestres
notes(3,0) = ( notes(3,1)+notes(3,2)+notes(3,3)+notes(3,4) )/_nbTrimestres


Si vous comparez le code ci-dessus à lʼoriginal, vous constaterez que notre unique variable tableau appelée notes remplace à elle seule une quinzaine de variables différentes tout en conservant lʼensemble des informations qui nous sont nécessaires. Très souvent lʼéconomie de moyens doit être recherchée pour programmer efficacement. Lʼécriture du code en sera facilitée, ainsi que le travail du Compilateur.

Imaginez à nouveau une classe de 40 élèves. Modifier notre code devient alors facile, car il suffit dʼattribuer à la constante _nbEleves la valeur 40 et dʼajouter autant de lignes de calcul que nécessaires en modifiant à chaque ligne les indices. Voilà qui est plus efficace, mais vous ne manquerez pas de vous dire que le travail est fastidieux quand même. Vous vous direz sans doute quʼil serait plus judicieux dʼavoir une seule formule à appliquer pour le calcul de la moyenne de chacun des élèves plutôt que de répéter 40 fois dans votre code essentiellement la même opération.

notes(1,0) = maFormuleMagique
notes(2,0) = maFormuleMagique
notes(3,0) = maFormuleMagique


Bravo, vous venez de saisir lʼidée des fonctions-utilisateur !

Vous vous direz sans doute également quʼil serait intéressant dʼavoir une méthode pour répéter automatiquement la même instruction autant de fois quʼil y a dʼélèves dans la classe :

notes(de 1 à _nbEleves,0) = maFormuleMagique

Bravo, vous venez de saisir lʼidée des boucles conditionnelles!

Notre code (factice) pourrait se résumer à ceci :

_nbEleves = 3
_nbTrimestres = 4
DIM notes(_nbEleves,_nbTrimestres) AS DOUBLE
notes(de 1 à _nbEleves,0) = maFormuleMagique


Comparé à notre code original, vous noterez que ce code est beaucoup plus condensé et quʼil a lʼavantage de sʼadapter à des situations différentes, cʼest-à-dire quʼil sʼécrira et fonctionnera pareillement quel que soit le nombre dʼélèves dans la classe en changeant simplement la valeur attribuée à la constante _nbEleves.

Par ce détour, nous avons anticipé sur les leçons à venir, mais vous découvrirez que la programmation demande très souvent la recherche dʼune bonne structuration de votre code.

Les tableaux peuvent avoir théoriquement jusquʼà 255 dimensions, mais pour dire la vérité, bien que les tableaux soient très fréquemment employés, on rencontre excessivement rarement des programmes qui utilisent des tableaux à plus de 3 dimensions.

Tous les types de variables peuvent être organisés en tableaux y compris les records :

DIM mesRectangles(10) AS RECT

Ci-dessus un tableau pouvant accueillir 11 structures RECT (de 0 à 10 inclus)

Les tableaux dynamiques
Il est des circonstances en programmation où lʼon ne connaît pas la quantité dʼéléments susceptibles de composer un tableau avant que le programme ne soit effectivement en action. Il faut donc pouvoir agrandir la taille du tableau au gré des besoins. Pour répondre à cette difficulté de programmation, FutureBASIC^3 offre plusieurs possibilités, la plus simple est dʼutiliser des tableaux appelés dynamiques. On déclare un tableau dynamique de lʼune des deux façons suivantes :

DYNAMIC mesRectangles(999999) AS RECT

ou

DIM DYNAMIC mesRectangles(999999) AS RECT

Ce quʼil faut noter avec les tableaux dynamiques, cʼest que lʼindice maximum utilisé lors de la déclaration, nʼa pas vraiment de signification, car la mémoire nʼest pas réservée comme elle le serait avec un tableau régulier, cʼest pourquoi cette valeur est choisie arbitrairement très grande sans pour autant risquer de saturer la mémoire. En réalité, cette valeur très grande n'est là que pour contourner une difficulté si vous avez coché l'option "Vérifier les limites de tableaux" dans le panneau des Préférences à l'onglet réglages avancés, car le compilateur vous signalera une erreur qui n'a pas lieu d'être si vous dépassez la limite indiquée comme indice dans l'instruction DIM. Cette option de vérification est utile pendant le développement et le débogage de votre programme, mais il est bon de la désactiver lorsque vous construirez votre application, car elle ralentit quelque peu les opérations. Vous pouvez également utiliser une constante comme indice maximal, et pourquoi pas _maxLong qui représente la valeur maximale d'un entier long, soit l2 147 483 647. Les indices sont toujours des entiers.

Le tableau est redimensionné automatiquement au gré de vos besoins, cʼest-à-dire que si votre code référence un élément quelconque du tableau, FutureBASIC se chargera, si nécessaire, de donner une taille adéquate au bloc de mémoire contenant les données afin quʼil puisse contenir lʼélément avec lʼindice spécifié. Exemple :

DYNAMIC mesValeurs(7777) AS INT
mesValeurs(100) = 20


Le Runtime examine sʼil peut accéder au 101e élément (numéroté 100), sʼil le peut, il affecte la valeur 20 à cet élément, sʼil ne le peut pas, il va accommoder la taille du tableau pour pouvoir affecter la valeur. En réalité, le Runtime augmente la taille du tableau en réservant de la mémoire pour plusieurs éléments à la fois, ce qui est censé diminuer le nombre de fois où le tableau doit être retaillé. Par défaut, chaque fois que le tableau devra être agrandi, FutureBASIC ajoutera un espace pouvant contenir 10 éléments supplémentaires. Cette opération consume du temps qui pourrait ne pas être négligeable si vous devez redimensionner fréquemment le tableau. Pour éviter cette pénalité, vous avez deux méthodes à votre disposition : vous pouvez obliger FutureBASIC à augmenter le nombre d'éléments de plus de dix à la fois en assignant une valeur plus grande à la variable globale du runtime gFBDynamicGrowInc, ou bien vous pouvez commencer par donner une valeur à l'élément du tableau ayant l'indice le plus élevé, puis vous assignerez les valeurs aux éléments d'indices inférieurs.

On a vu que le redimensionnement des blocs en mémoire sʼeffectuait au moyen de handles, les tableaux dynamiques sont, comme les containers, des handles déguisés. Ils nécessitent de même une gestion particulière et quelques commandes spécialisées sont fournies à cet effet.

Les tableaux dynamiques sont un outil efficace, mais à lʼimage des containers, ils souffrent aussi dʼune limitation dont nous reparlerons plus loin.

Les tableaux INDEX$
Les tableaux permettent de manipuler des grandes quantités de données bien ordonnées en mémoire et en de maintes occasions, ils simplifient lʼécriture du code puisquʼils permettent dʼappliquer facilement les mêmes traitements à des collections dʼéléments.

Les chaînes de caractères peuvent elles aussi être organisées en tableaux, mais on a vu également que leur occupation en mémoire était beaucoup plus importante que celles des nombres. Pour apporter une solution à ce problème et à quelques autres encore, FutureBASIC propose des tableaux que lʼon pourrait dire « préfabriqués ». Les tableaux INDEX$ sont des matrices réservées à lʼusage des chaînes de caractères. FB vous permet dʼutiliser 10 matrices, numérotées de 0 à 9, pour stocker des collections de chaînes de caractères. Lorsque vous utilisez des tableaux INDEX$ pour stocker des chaînes, vous aurez accès à des fonctions qui simplifient la manipulation des tableaux, comme supprimer ou insérer un élément et même rechercher un élément spécifique.

Deux types de tableaux INDEX$ peuvent être déclarées, les uns stockent des chaînes dont la longueur est variable et les autres des chaînes dont la longueur est fixe. Lorsque vous réservez la mémoire pour le tableau INDEX$, suivant la syntaxe que vous allez utiliser, vous déclarerez lʼun ou lʼautre de ces types de tableaux. Les tableaux de chaînes à longueur variable utilisent plus efficacement la mémoire du fait quʼaucune case en mémoire nʼest « gaspillée », les chaînes se suivant les unes à la suite des autres, tandis que les tableaux de chaînes fixes offrent des traitements plus rapides mais peuvent laisser des cases inutilisées en mémoire. Cʼest à vous quʼil revient de déterminer le type de tableau qui est le plus adapté à ce que vous voulez faire. Les tableaux INDEX$ doivent être initialisés et libérés. Par exemple pour initialiser deux tableaux INDEX$ illustrant les deux types mentionnés :

CLEAR 2000,0
CLEAR 20,1,45


La première syntaxe ci-dessus, réserve 2000 octets pour le tableau INDEX$ numéroté 0. Les chaînes auront des longueurs variables.

La seconde syntaxe initialise le tableau INDEX$ numéroté 1 pour 20 éléments ayant chacun 45 octets de longueur.

On peut ensuite accéder aux éléments individuellement en spécifiant leur rang et le numéro du tableau INDEX$ utilisé :

INDEX$(5,0) = "5e élément du tableau INDEX 0"

Lʼinstruction ci-dessus range la chaîne littérale dans le tableau INDEX$ numéroté 0 à la cinquième place.

DIM laChaine AS STR255
laChaine = INDEX$(2,1)


Lʼinstruction ci-dessus lit le deuxième élément du tableau INDEX$ numéroté 1 et le range dans la variable laChaine.

Les tableaux INDEX$ peuvent être redimensionnés au gré de vos besoins à lʼaide de la commande CLEAR. La fonction MEM de FutureBASIC peut vous aider dans la gestion de la mémoire avec ce type de tableau en fournissant toutes les informations nécessaires (mémoire inutilisée dans le tableau, nombre dʼéléments, etc.)

Il nʼest pas indispensable dʼutiliser les tableaux INDEX$ lorsquʼon a besoin dʼun tableau de chaînes de caractères, mais certains programmeurs aiment bien les employer pour les fonctions préprogrammées offertes par le runtime et ils sont aussi la garantie dʼune gestion efficace et rapide de la mémoire.

Les tableaux XREF
Enfin, il existe une commande très puissante, qui a souvent les faveurs des programmeurs FutureBASIC, pour déclarer des matrices. Les commandes XREF sʼapparentent aux tableaux dynamiques, dʼailleurs pendant longtemps cʼétait la seule façon de créer ce type de tableaux avec FB. On déclare un tableau XREF de la manière suivante :

XREF mesValeurs(88888) AS INT

La commande XREF, tout comme la commande DYNAMIC, ne réserve pas la mémoire pour le tableau. En fait, la commande ne fait que définir un prototype, un modèle de tableau. Elle indique au Compilateur que vous avez lʼintention dʼutiliser une zone-mémoire quelconque à la manière d'un tableau dont vous choisissez arbitrairement le type des valeurs quʼil contient. La commande XREF peut troubler les débutants parce quʼelle nécessite une seconde étape : tout simplement, il faut indiquer au Compilateur lʼadresse en mémoire du bloc que vous voulez examiner comme une matrice. Pour indiquer le bloc mémoire que lʼon souhaite ‟transformer” en tableau, on utilise une variable que le Compilateur a déclarée pour nous sans que nous ayons eu à la dimensionner explicitement. Cette variable porte le nom du tableau auquel le suffixe & est ajouté optionnellement pour la distinguer.

mesValeurs& = adresseMemoire

Après quoi, on peut utiliser le tableau mesValeurs comme un tableau ordinaire.

Prenons un exemple plus concret : nous avons vu que les chaînes de caractères nʼétaient quʼune suite dʼoctets (un octet de longueur, suivi du code ASCII des caractères qui la composent). On peut donc facilement imaginer cette suite dʼoctets en mémoire comme un tableau dʼoctets.

DIM AS STR255 uneChaine
XREF tableauOctets(256) AS CHAR

uneChaine = "FutureBASIC"
tableauOctets& = @UneChaine


Les instructions ci-dessus déclarent une chaîne de caractères à laquelle est affectée pour notre exemple la chaîne littérale « FutureBASIC ». Puis un prototype pour un tableau dʼoctets (type CHAR ou BYTE) est déclaré. On utilise 256 comme indice maximal parce qu'une chaîne Pascal occupe 256 octets au maximum. Ensuite on affecte à la variable tableauOctets& (créée par le Compilateur) lʼadresse de notre chaîne. On peut enfin parcourir notre tableau dʼoctets pour examiner les octets individuels stockés à lʼadresse de la chaîne.

tableauOctets(0) contiendra le premier octet (rappelez-vous, les tableaux commencent à lʼindice 0), en lʼoccurrence, puisque notre zone en mémoire contient une chaîne Pascal, se sera lʼoctet de longueur.

tableauOctets(0) sera égal à 11 (le mot FutureBASIC contient 11 caractères). tableauOctets(1) sera égal au code ASCII du caractère F (en majuscule) soit 70. tableauOctets(2) sera égal à _‟u‟, etc.

On vient de réaliser ce que fait essentiellement la syntaxe entre crochets que nous avons déjà étudiée pour les chaînes et qui nous permet dʼaccéder aux octets individuels qui composent une chaîne de caractères.

tableauOctets(0) = uneChaine[0]
tableauOctets(1) = uneChaine[1],
etc.

Il y a deux variantes pour la commande XREF, lʼune (XREF) sʼattend à travailler avec lʼadresse (un pointeur) du bloc en mémoire que lʼon veut examiner comme un tableau, lʼautre (XREF@) attend un handle pointant sur un bloc relogeable en mémoire.

Lʼautre difficulté avec la commande XREF est de déterminer lʼindice maximal qui peut être employé avec le tableau, car, bien entendu, il nʼest pas question de déborder des limites du bloc mémoire que nous utilisons sous peine dʼerreurs système. Pour déterminer cet indice, il suffit de diviser la taille du bloc mémoire par la taille d'un élément quelconque que le tableau est censé contenir et ne pas oublier que les tableaux dans FutureBASIC commencent toujours à l'indice 0. Par conséquent on retranchera une unité au résultat de cette division.

DIM AS LONG i, indexMax
XREF@ tableauEntiers(99999) AS INT

tableauEntiers& = monHandle
indexMax = (FN GetHandleSize(monHandle)/SIZEOF(INT))-1
FOR i = 0 TO indexMax
  tableauEntiers(i) = tableauEntiers(i) + 1
NEXT


L'exemple ci-dessus déclare un prototype de tableau d'entiers qui sera référencé par un handle. Puis il désigne le bloc mémoire qui est supposé contenir les éléments de la matrice au moyen d'un handle (on assume ici que le handle monHandle a été créé ailleurs dans le programme). Le code calcule ensuite l'indice maximal utilisable pour ce tableau en fonction de la taille du bloc mémoire référencé par le handle et de la taille de chaque élément. SIZEOF(INT) retourne la valeur 2, car un entier occupe 2 octets en mémoire. Puis une boucle passe en revue chacun des éléments du tableau et lui ajoute une unité. Nous verrons un peu plus loin comment manipuler les boucles.

Gardez à l'esprit que le type des éléments qui composent le tableau est laissé à votre discrétion; le même bloc mémoire peut être examiné comme une suite d'octets, d'entiers courts, ou d'entiers longs, ou pourquoi pas de rectangles si vous le souhaitez. FutureBASIC ne bronchera pas même si vous écrivez des absurdités. Notez aussi que vous pouvez changer à tout moment de bloc mémoire en assignant au pointeur du tableau (tableauEntiers& dans notre exemple) un autre handle. La commande XREF offre donc une certaine flexibilité qui ne peut être obtenue avec l'utilisation de variables "normales".

La variante XREF@ permet de créer aisément des tableaux dont le nombre d'éléments n'est pas connu à l'avance par le programmeur. L'utilisation de handles est plus efficace dans une telle situation, car le système rencontrera moins de difficultés à retailler des blocs relogeables que des blocs fixes. En agrandissant ou racourcissant un bloc relogeabe grâce à la procédure de la Toolbox SetHandleSize, le programme pourra ainsi créér virtuellement un tableau dynamique avec le nombre exact d'éléments dont il a besoin. Confrontés à une situation similaire, les débutants souvent intimidés à la fois par les handles et la commande XREF@, préfèrent déclarer un tableau avec la commande DIM en lui attribuant un très grand indice dont ils estiment qu'il ne sera jamais atteint par le programme durant son exécution. Il y a ici un gaspillage de mémoire d'autant plus pénalisant qu'un tableau de cette nature est déclaré en variable globale et ne pourra plus jamais être détruit au cours du programme, même si celui-ci n'en a plus besoin. En revanche, un handle peut être retaillé jusqu'à une taille de 0 octet ou bien il peut être totalement détruit avec la commande de la Toolbox DisposeHandle si le programme n'en a plus besoin.

En réalité la puissante commande XREF, bien quʼintimidante pour le débutant, est très simple à utiliser, une fois que le concept a été assimilé. Gardez en mémoire que la commande DIM réserve le bloc mémoire pour un tableau tandis que la commande XREF est essentiellement employée avec un bloc déjà créé par ailleurs dans votre code pour le traiter comme un tableau.

Les tableaux dans les champs des records
Pour terminer ce tour dʼhorizon concernant les matrices, sachez que les records peuvent avoir des champs de type tableau à une dimension. Pour déclarer une matrice dans un champ de record on utilise les crochets et non pas les parenthèses. Exemple :

BEGIN RECORD Objet
  DIM epaisseur      AS INT
  DIM coordonnees[3] AS INT
END RECORD


Le record défini ci-dessus contient un champ sur un entier court (epaisseur) suivi dʼun tableau de 4 entiers courts appelés coordonnees (indice de 0 à 3 inclus).

On accède à un élément du tableau contenu dans le champ de la manière suivante :

DIM monObjet AS Objet
monObjet.coordonnees[0] = 10
monObjet.coordonnees[1] = 20

etc.

Notez encore lʼutilisation des crochets.

Ici sʼachève notre premier inventaire qui vous aura donné un aperçu des outils de base mis à notre disposition. Il nʼest pas raisonnable de penser que vous pouvez assimiler lʼensemble de la ménagerie dès la première lecture. Si ça peut vous rassurer, il y a des programmeurs de longue date en BASIC qui font dʼexcellents programmes sans avoir abordé certains des concepts qui ont été évoqués jusquʼici. Cependant, le typage des variables est un aspect essentiel de la programmation, en effet, une bonne compréhension des entités que vous manipulez vous aidera à travers les milliers de fonctions de FutureBASIC, de la Toolbox et de la multitude dʼexemples que vous allez rencontrer ultérieurement. Cette notion est si importante que je vous conseille de revenir sur les chapitres antérieurs si trop de points sont restés obscurs.

Dans tous les petits bouts de code présentés jusquʼici, toutes nos variables ont été déclarées avec lʼinstruction DIM qui alloue explicitement un espace en mémoire adéquat au type spécifié par la clause AS. Il faut savoir que FutureBASIC, comme tous les autres BASIC, vous autorise à utiliser des variables de types communs sans que vous ayez pris le soin de les déclarer explicitement. Quʼest-ce que cela veut dire exactement ?

Lorsque vous écrivez ceci :

x% = 10
a$ = "Une chaîne"
z& = 45589 + x%


Le Compilateur peut créer automatiquement les variables à mesure quʼil les rencontre pour la première fois dans une instruction. Lʼespace mémoire réservé pour chacune des variables dépend de lʼidentificateur de type accolé au nom de la variable. On comprend tout de suite la facilité, puisquʼon est dispensé de la déclaration DIM pour les variables dʼun type commun, mais autant le dire tout de suite, ce nʼest pas une bonne pratique. Même après des années de programmation, on peut faire des erreurs de débutants en adoptant cette façon de faire : le Compilateur ne corrigera pas vos fautes de frappe à votre place en devinant votre intention, et pour lui lʼinstruction suivante sera parfaitement valide :

horizontal = horzontal + 1

Vous ne manquerez pas dʼexpérimenter par vous-même à quel point ces erreurs surviennent plus fréquemment quʼon ne lʼimagine. Dans des programmes conséquents, il nʼest pas toujours facile de les débusquer, car vos applications continueront à fonctionner correctement, du moins en apparence. FutureBASIC dispose dʼune option selon que vous aimez le risque et les frustrations que cela peut engendrer ou bien que vous préférez programmer avec plus de rigueur. Vous pouvez demander au Compilateur de sʼarrêter dès quʼil rencontre dans votre programme une variable qui nʼa pas été déclarée en cochant dans la boîte de dialogue des préférences la case « Utiliser seulement les variables déclarées ». En principe, cette case est cochée par défaut, et il est très vivement conseillé de la laisser dans cet état, vous serez alors contraint de déclarer toutes vos variables, mais vous prendrez dès le départ de bonnes habitudes que vous n'aurez pas l'occasion de regretter.



[Precédent] [Table des Matières] [Suivant]
{Note}
© 2000 Pix&Mix
Tous droits réservés

FutureBASIC est une marque déposée appartenant à Staz Software, Inc et utilisée avec permission.