![[EN]](../../pix-bin/Drapeau/EN_OFF.gif "This web site in English"){kind=small}
![[IT]](../../pix-bin/Drapeau/IT_OFF.gif "Il sitio en Italiano"){kind=small}
![[INFO]](../../pix-bin/info2_on.jpg){kind=small}
![[ACQUÉRIR]](../../pix-bin/Tab-bin/fr_buy1_on.jpg "Où et comment acheter FutureBASIC"){kind=small}
![[PLAN]](../../pix-bin/Tab-bin/fr_map1_on.jpg "Le plan du site"){kind=small}
![[RESSOURCES]](../../pix-bin/Tab-bin/fr_res1_on.jpg "Tout ce qui tourne autour de FB"){kind=small}
|
|
|
|
|
|
|
|
|
|
|
|||||
|
|||||||
|
|
|
|
|
|||
|
|
|
|
||||
|
|||||||
| CHAPITRE
|
APPRENDRE
À PROGRAMMER AVEC FUTUREBASIC
|
NOTES
|
|
Les matrices Les tableaux simples |
Leçon 8 : Les
variables ordonnées (les tableaux ou matrices) 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 pour l'indice dans l'instruction DIM. Cette option 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 comme 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} |
 |
||
 |
||
|
FutureBASIC est une marque déposée appartenant à Staz Software, Inc et utilisée avec permission. |
||