[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
INFO  |  ACQUÉRIR |  PLAN  |  RESSOURCES
Charte Vie Privée  
Infos Légales  

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