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

Les Variables I

Les entiers
Les booléens

Leçon 4 : variables à géométrie variable


Avec les instructions, les opérateurs et les variables, on peut dʼores et déjà commencer à programmer. Mais il y a une chose très importante à savoir concernant les variables, aussi nous nʼallons pas nous lancer tête baissée, sans avoir abordé le sujet, car une fois que les concepts développés plus avant auront été assimilés, vous naviguerez beaucoup plus aisément dans lʼunivers parfois tortueux de la programmation.

La chose importante à connaître est la suivante : les variables possèdent un type qui leur est propre et qui spécifie les valeurs quʼelles sont susceptibles de contenir. Le type que vous attribuez à une variable indiquera dʼune part, lʼespace en mémoire nécessaire pour stocker la valeur quʼelle contiendra, (eh oui, les variables nʼoccupent pas la même place en mémoire vive), et dʼautre part, vous indiquerez au Compilateur comment il doit interpréter le contenu rangé à lʼadresse mémoire de la variable.

Vous vous rappelez que le processeur ne connaît que deux états ? Lʼinformation la plus fondamentale est appelée ‟bit” (binary digit ou chiffre binaire). Traditionnellement on dit quʼun bit vaut 0 ou bien 1. Si lʼon devait en rester là, on nʼirait pas bien loin. Bien quʼil soit tout à fait possible de travailler à ce niveau fondamental et de modifier les bits individuellement, ils sont le plus souvent considérés par lots de 8 bits. Une série de 8 bits consécutifs est la valeur élémentaire que nous aurons le plus souvent à traiter. Cette série est appelée un octet (ou byte en anglais). Voici une représentation possible dʼun octet : 00101101

Comment cette série de 8 bits peut-elle être représentée pour un être humain normalement constitué ?

Pour convertir ces bits en une représentation décimale, on peut utiliser la puissance de 2. On va faire une simple addition en commençant par le bit le plus à droite.
valeur du premier bit multiplié par 2 puissance 0 (notez que 2^0 = 1)
additionnée à
valeur du second bit multiplié par 2 puissance 1
additionnée à
valeur du troisième bit multiplié par 2 puissance 2
etc.



Si vous faites le calcul avec tous les bits positionnés à 1, le total vaut 255. Lorsquʼils sont tous à 0, le total vaut 0 également. Un octet peut donc représenter 256 valeurs entières positives allant de 0 à 255 (inclus).

Les nombres négatifs peuvent aussi être représentés avec un octet, mais lʼinformation concernant le signe du nombre (positif ou négatif) doit bien être stockée quelque part. Sur le Mac, cʼest le bit le plus à gauche qui sera utilisé pour contenir cette information, et lʼon voit quʼil ne pourra plus faire partie du calcul pour retrouver la valeur décimale du nombre comme montré dans le schéma ci-dessus . Seuls les 7 bits sur la droite sont disponibles pour le calcul. Le nombre de valeurs possibles pouvant être représentées sera le même, mais les valeurs seront maintenant distribuées dans la plage [-128, +127]

Pour représenter un nombre plus grand que 255, par exemple 810, il suffit dʼutiliser un octet supplémentaire (sur la gauche) et de continuer le calcul sur le principe qui a été montré précédemment. Les variables peuvent donc avoir des tailles différentes selon ce que nous voulons représenter. Pour que le Compilateur sʼy retrouve, nous devons déclarer la dimension de chacune des variables que nous allons utiliser dans notre programme. Lʼinstruction DIM est prévue à cet effet.

Les variables sont en réalité classées par type. Le type donne une indication à la fois sur la taille en octets (la place quʼelles occupent en mémoire) et sur les valeurs quʼelles peuvent représenter.

Les entiers
Les valeurs entières (non fractionnaires) sont généralement stockées dans des variables ayant lʼun des types figurant dans le tableau ci-dessous. Ce tableau vous montre lʼoccupation en mémoire, la plage des valeurs représentables et enfin la façon de déclarer des variables dans le code source soit à lʼaide dʼun suffixe, soit à lʼaide de la clause AS pour chacun des types listés :

Type Stockage Intervalle Identification de Type
octet signé 1 octet [-128, +127] DIM x`
DIM x AS BYTE
DIM x AS CHAR
octet non signé 1 octet [0, 255] DIM x``
DIM x AS UNSIGNED BYTE
DIM x AS UNSIGNED CHAR
entier court signé 2 octets [-32768, +32767] DIM x%
DIM x AS INT
DIM x AS WORD
DIM x AS SHORT
entier court non signé 2 octets [0, 65535] DIM x%`
DIM x AS UNSIGNED INT
DIM x AS UNSIGNED WORD
DIM x AS UNSIGNED SHORT
entier long signé 4 octets [-2147483648, +2147483647] DIM x&
DIM x AS LONG
entier long non signé 4 octets
[0, 4294967295]
DIM x&`
DIM x AS UNSIGNED LONG

Vous avez sans doute noté que BYTE et CHAR sont synonymes, il en va de même pour INT, WORD et SHORT. Vous choisirez la syntaxe qui vous convient le mieux. Cʼest lʼoccasion de dire ici, que FutureBASIC^3 autorise beaucoup de variations dans lʼécriture du code, mais cet atout que les programmeurs apprécient peut sʼavérer être un handicap pour un novice qui fait ses tout premiers pas en programmation.

Le typage des variables est une notion essentielle à assimiler pour évoluer aisément par la suite. Traditionnellement en BASIC, le typage est réalisé à lʼaide dʼun suffixe ajouté au nom de la variable. Cette façon de faire est toujours disponible avec FB, le tableau ci-dessus montre dʼailleurs les suffixes identificateurs de type pour tel ou tel type de variable. Les manuels de FutureBASIC font un usage intensif de cette ‟ancienne” forme, il faut donc lʼapprendre aussi. Si vous typez vos variables avec cette méthode, vous devrez prendre un très grand soin lors de la rédaction de vos instructions en nʼoubliant pas dʼajouter lʼidentificateur de type chaque fois que vous devrez utiliser les variables. Quant à nous, nous privilégierons autant que faire se peut la forme plus moderne, car, à notre sens, elle rend le code plus lisible.

Notez dès à présent que déclarer une variable (on dit aussi dimensionner) nʼest pas équivalent à lʼinitialiser. Lʼinstruction DIM prévient le Compilateur que nous voulons utiliser un certain type de variable, ce qui lui donne une indication sur la taille du bloc en mémoire quʼil doit lui réserver, tandis que lʼinitialisation consiste à attribuer une valeur initiale à une variable. Le fait de déclarer une variable ne donne aucune information au Compilateur quant à son contenu si ce n'est comment il devra l'interpréter. Le plus généralement, on initialise une variable au moyen de lʼopérateur dʼassignation :

REM déclaration
DIM x AS SHORT
REM initialisation
x = 10

Vous ne devez pas assumer que la variable x vaut 0 après sa déclaration. Cela dit, FutureBASIC comme les autres BASIC autorise lʼutilisation de variables non préalablement déclarées :

REM auto-déclaration et initialisation
x% = 10


Bien que cette option soit disponible (cf. lʼonglet variables de la fenêtre de dialogue des préférences), il nʼest pas recommandé de lʼactiver, car même si elle semble faciliter la vie des débutants, elle peut tout aussi bien la leur compliquer. Par exemple, avec cette option validée, le compilateur ne vous signalera pas dʼerreur dans les lignes de code suivantes :

valeurIndice = 45
total = codeBase * valerIndice


Dans ce cas de figure, lorsque le Compilateur rencontrera pour la première fois une variable dans une ligne de code, il la déclarera gracieusement pour vous et il ne corrigera pas vos fautes de frappe à votre place. Il est facile de commettre de telles erreurs, et vous verrez quʼon en fait plus souvent quʼon ne le voudrait, en revanche, il nʼest pas toujours aisé de repérer ce type dʼerreur dans des programmes conséquents. En résumé, cette facilité peut avoir un prix à payer, dont on peut se passer en sʼobligeant à déclarer avec lʼinstruction DIM toutes les variables que nous avons lʼintention dʼutiliser.

Une fois déclarées, les variables ne peuvent plus changer de type pendant toute la durée de leur existence (eh oui, on verra que les variables meurent aussi), cʼest pourquoi il faut prêter une attention particulière au type que vous donnerez à une variable lors de sa déclaration en fonction des valeurs quʼelle pourrait contenir durant lʼexécution de votre programme. Il est cependant possible avec certaines limitations dʼassigner à une variable dʼun certain type la valeur contenue dans une variable dʼun type différent. Le Compilateur fera de son mieux pour convertir la valeur de la variable source dans celle de destination.

Les booléens
Il existe un type de variable appelé BOOLEAN dont lʼespace de stockage est de 1 octet et qui sert à maintenir une information dont les valeurs sont adaptées pour représenter des états opposés : éteint ou allumé, inactif ou actif, faux ou vrai, nul ou non nul. Le plus souvent, on assigne aux variables de type BOOLEAN des constantes prédéfinies :

DIM x AS BOOLEAN
x = _false
x = _true

Si la valeur 0 de la constante _false symbolisant la valeur FAUX ne pose pas de problème, il nʼen va pas de même avec la valeur VRAI, car FutureBASIC dispose de trois constantes pour symboliser la valeur VRAI : _true, _pTrue, _zTrue qui ont respectivement les valeurs 1, 256 et -1 et qui sont les représentations pour la valeur VRAI dans les langages C, Pascal et FutureBASIC.

Dû à lʼarrangement interne des bits qui la composent, la constante _zTrue propre à FutureBASIC a une particularité intéressante lorsquʼelle est utilisée avec lʼopérateur NOT :

_false = NOT(_zTrue)
_zTrue = NOT(_false)


Les égalités ci-dessus ne sont pas vraies avec les constantes _pTrue et _true , car NOT(_pTrue) sera égal à -257 et NOT(_true) à -2.

Notez que le résultat dʼune expression peut être assigné à une variable booléenne. Considérez les instructions suivantes :

DIM vraiOuFaux AS BOOLEAN
vraiOuFaux = (1 = 2)
vraiOuFaux = (1 = 1)


Avant dʼassigner la variable vraiOuFaux, FutureBASIC évalue lʼexpression à la droite de lʼopérateur dʼassignation, le signe égal entre les parenthèses est ici lʼopérateur de comparaison. La première expression sera évaluée à 0 ou _false (1 nʼétant pas égal à 2), tandis que la seconde sera évaluée à -1 correspondant à _zTrue.

FutureBASIC permet dʼutiliser lʼopérateur de comparaison hérité du langage C pour éviter la confusion entre lʼassignation et la comparaison. Cet opérateur optionnel est composé de deux signes égal. On aurait donc pu écrire ceci :

DIM vraiOuFaux AS BOOLEAN
vraiOuFaux = (1 == 2)
vraiOuFaux = (1 == 1)


Cette singularité concernant la valeur VRAI peut surprendre et provoquer des dysfonctionnements dans vos programmes qui ne sont pas toujours faciles à traquer, car certaines fonctions de la Toolbox retournant une valeur booléenne utilisent la valeur VRAI du Pascal (_pTrue). Le plus simple est dʼéviter de tester si une variable booléenne contient une valeur VRAI (_true, _pTrue ou _zTrue), on testera à la place si sa valeur est nulle (_false) ou bien non nulle.



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