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

Les outils du programmeur

Mots-clés
Variables
Opérateurs
Constantes

Leçon 3 : Bon ça commence ?


Nous venons de voir que FutureBASIC est constitué de différents composants logiciels - un éditeur, un compilateur et divers runtimes - mais pour les impatients que vous êtes, sachez que ce nʼest pas tout, car cʼest aussi un gestionnaire de projets, un profileur , un générateur dʼinterface et dʼautres choses encore, mais cela viendra en son temps. La tour de contrôle est en fait lʼÉditeur à partir duquel vous invoquez tous les autres outils à lʼexception notoire du générateur dʼinterface (appelé indifféremment Program Generator, PG ou encore PG Pro).

Comme vous pouvez le conclure FutureBASIC nʼest pas un outil unique mais un ensemble dʼoutils; on appelle cela un IDE (Integrated Development Environment ou Environnement de développement intégré).

Bien que cela ne soit pas du tout indispensable pour débuter, il est toujours bon dʼavoir un aperçu du propriétaire. Voici une illustration vous montrant comment lʼenvironnement de programmation est organisé sur le CD-ROM.



Dans cette organisation, le dossier FB Extensions contient toute la machinerie interne de lʼenvironnement, et en principe, vous nʼavez pas à manipuler ce dossier. En fait, vous accédez indirectement à son contenu à travers lʼÉditeur (dénommé ici FB^3 IDE Release 4). Vous avez peut-être remarqué lʼabsence du générateur dʼinterface dans la copie dʼécran ci-dessus. Program Generator est une application autonome qui nʼest pas encore pilotée à travers lʼÉditeur. Il est probable cependant que dans lʼavenir cet outil fasse partie intégrante de lʼenvironnement.

Pour commencer à programmer, tout ce que vous avez à faire cʼest un double-clic sur lʼÉditeur (attention : pour travailler, FutureBASIC a besoin dʼécrire un certain nombre de fichiers sur le disque, en conséquence, vous ne pouvez pas exploiter lʼenvironnement correctement depuis le CD-ROM sur lequel il est livré et vous devez dʼabord copier lʼensemble des fichiers sur votre disque dur.)

Une fois dans lʼÉditeur, vous créez un nouveau document (menu Fichier, article Nouveau), et soudain vous vous retrouvez confronté à lʼangoisse du créateur devant sa page blanche.

De quoi disposez-vous pour programmer? 

Les mots-clés
Tout dʼabord vous avez à votre disposition un ensemble de mots-clés pour écrire vos instructions. Il nʼy a pas de mystère ici, il vous faudra les apprendre en consultant le manuel de Référence. Notez que vous pouvez avoir accès à tout moment à ce manuel depuis lʼapplication Éditeur en sélectionnant dans le menu Aide lʼarticle approprié, donc ce nʼest pas bien grave si vous ne mémorisez pas immédiatement la subtilité dʼécriture de toutes ces instructions. Même après 10 années à programmer avec FutureBASIC, vous continuerez à visiter cette documentation, c'est d'ailleurs une très bonne idée en soi, car le manuel aussi évolue à chaque fois qu'une nouvelle version de FutureBASIC est délivrée pour, d'une part corriger d'éventuelles erreurs qui s'y seraient glissées, mais surtout parce que toutes les nouveautés y sont recensées et commentées.

Les mots réservés du BASIC ont ce quʼon appelle une syntaxe montrant le type et lʼordre des paramètres quʼils acceptent. Les paramètres sont des valeurs que vous passez à lʼinstruction pour quʼelle accomplisse un travail particulier. Il y a deux catégories dʼinstructions que le manuel distingue avec les dénominations ‟commande” et ‟fonction”. Une commande est une instruction qui exécute des traitements, tandis quʼune fonction exécutera aussi des traitements, le plus souvent des calculs, mais retournera une valeur, un résultat.

Les variables
La plupart du temps, les valeurs manipulées par vos programmes ont besoin dʼêtre modifiées durant lʼexécution, si ce nʼétait pas le cas, vos programmes feraient exactement les mêmes choses de session en session, produisant toujours les mêmes résultats et les mêmes documents et avec eux un ennui profond. Ces valeurs sont stockées dans ce quʼon appelle des variables, car justement leur contenu nʼest pas fixe et est appelé à changer dans les diverses circonstances traitées par votre application.

On peut imaginer une variable comme une case ou un tiroir dans lequel vous rangez des valeurs. En général, ces tiroirs ont un emplacement physique dans la mémoire vive de votre ordinateur (en RAM) et donc les valeurs quʼils contiennent disparaissent dans le néant lorsque vous éteignez votre ordinateur. Lʼemplacement physique est appelé lʼadresse-mémoire (ou plus simplement lʼadresse) de la variable. Il est important de faire tout de suite cette distinction : une variable possède une adresse et à cette adresse est rangée une valeur. Lʼadresse de la variable reste fixe et seule la valeur quʼelle contient sera modifiée par vos instructions.

Pour compliquer un peu les choses, il faut savoir quʼavec les processeurs PPC qui équipent les PowerMacintosh, toutes les variables ne sont pas obligatoirement créées en mémoire vive. Ces processeurs disposent d'un petit nombre de « cases » spéciales (appelées registres) dans lesquelles des valeurs peuvent être momentanément stockées. Le processeur accède beaucoup plus rapidement aux registres quʼà la mémoire vive, ce qui permet dʼaccélérer parfois de manière très significative les traitements.

Une variable qui sera créée en registre nʼaura donc pas dʼadresse mémoire, cela a des implications pour nous en tant que programmeurs, et nous verrons par la suite comment il est simple avec FutureBASIC de gérer cette spécificité, mais pour le moment nous laisserons de côté ce sujet afin de nous concentrer sur le raisonnement.

On peut se représenter la portion de mémoire vive allouée à une application comme un empilement de tiroirs ou de cases mémoire. Toutes ces cases ont une adresse physique, mais toutes ne sont pas nécessairement lʼadresse dʼune variable.

Il nʼest pas important de connaître précisément lʼadresse mémoire dʼune variable, car en réalité, cette adresse sera très probablement différente entre deux exécutions successives de votre programme. Pour sʼy retrouver on désigne les variables au moyen dʼun nom symbolique qui fait référence de manière abstraite à cette case en mémoire. On manipule ensuite, dans les instructions, les variables par leur nom symbolique, exactement comme on le ferait pour résoudre des problèmes d'algèbre. Bien entendu, cʼest vous, en tant que programmeur, qui attribuez ce nom à votre convenance, il y a cependant un certain nombre de règles à respecter pour ce nommage : évidemment, vous ne devez pas utiliser des mots-clés qui sont réservés pour les instructions du BASIC, sans quoi le Compilateur ne pourra pas distinguer une variable dʼune instruction. Dʼautre part, le nom doit débuter par une lettre de lʼalphabet et ne doit pas contenir dʼespace, ni dʼautres symboles réservés par FutureBASIC. Voici, des noms de variables valides. Une convention largement répandue veut que nous fassions commencer le nom des variables que nous créons par une lettre minuscule. Rien ne vous y oblige et c'est à vous de voir :

x
z4
ceciEstUneVariableQuiPeutContenirUneValeur


Attention : FutureBASIC ne tient pas compte de la casse des caractères si bien que maVariable, MAVARIABLE, MaVaRiaBLe sont pour lui des noms identiques.

Les opérateurs
Pour manipuler le contenu des variables, vous disposez dʼun certain nombre dʼopérateurs. Les plus usités sont les suivants (il en existe dʼautres que nous verrons ultérieurement) :

= (affectation ou comparaison)
+ (addition)
- (soustraction ou changement de signe)
* (multiplication)
/ (division)
^ (puissance)
< (inférieur)
<= ou =< (inférieur ou égal)
> (supérieur)
=> ou >= (supérieur ou égal)
<> ou != (différent)
== (comparaison héritée du langage C)

Par exemple, pour affecter à la variable y le double de la valeur contenue dans la variable x vous pourriez écrire ceci :

y = 2 * x

Il est important de noter dès à présent que les opérations sont réalisées en tenant compte de la priorité des opérateurs. Prenons un exemple simpliste :

Imaginez que vous ayez une variable x dont la valeur est 10

x = 10

et que vous souhaitiez maintenant ajouter 2 à cette valeur, puis multiplier le résultat par 3 avant de lʼaffecter à une variable y. À la fin des opérations, y devrait donc contenir la valeur 36 (10 + 2 = 12; 12 X 3 = 36). Maintenant, si vous écrivez ceci :

y = x + 2 * 3

vous risquez dʼêtre surpris de constater que la variable y vaudra 16 à la fin des opérations. Cela tient au fait que la multiplication est prioritaire sur lʼaddition et quʼelle est exécutée en premier. Le calcul effectué est donc le suivant : 2 * 3 = 6; 10 + 6 = 16.

Avec lʼhabitude, la priorité des opérateurs vous sera tellement familière que vous nʼy penserez plus, mais pour éviter ce genre de surprise lorsquʼon débute, il est recommandé dʼutiliser les parenthèses afin dʼisoler les parties du calcul dans le cas dʼexpressions un peu complexes. Nous vous renvoyons au Manuel de Référence pour consulter le tableau des priorités des opérateurs. Vous auriez donc dû écrire ceci, pour obtenir la valeur 36 recherchée :

y = ( x + 2 ) * 3

Ci-dessus, le Compilateur est informé quʼil devra exécuter lʼexpression entre parenthèses, cʼest-à-dire ici, une addition, avant la multiplication qui est normalement prioritaire. À la manière de poupées russes, des parenthèses peuvent contenir d'autres calculs placés eux-mêmes entre parenthèses.

Les constantes
En dehors des variables qui contiennent des valeurs qui évoluent durant l'exécution du programme, on manipule souvent des valeurs qui restent fixes pendant toute la durée du programme. FutureBASIC permet également de donner un nom symbolique à ces valeurs qui restent constantes. Le nom attribué à ces constantes doit débuter par le caractère de soulignement. On utilisera ainsi le nom des constantes en lieu et place des valeurs littérales.

Dans lʼexemple mentionné précédemment 10 et 3 sont des valeurs fixes (lorsque vous écrivez des valeurs telles quelles, en chiffres arabes, dans votre code source on parle de valeurs littérales).

Grâce à lʼutilisation de constantes symboliques, le code devient tout de suite plus facile à comprendre et on a immédiatement une idée plus précise de ce que lʼinstruction est censée faire. On pourrait avoir éventuellement quelque chose comme ceci:

_baseMatiere = 10
_coefficient = 3
y = (_baseMatiere + x) * _coefficient


Une fois quʼune constante a été déclarée, toutes les parties de votre code peuvent accéder à la valeur quʼelle représente. On verra que cette particularité ne sʼapplique pas aux variables qui ont ce quʼon appelle une portée, cʼest-à-dire un domaine de validité.

Si vous devez modifier une constante lors de la phase de développement de votre programme, vous nʼaurez quʼun seul emplacement à retrouver dans votre code source pour changer sa valeur et votre modification sera prise en compte instantanément par toutes les autres parties du code qui font appel à cette constante.

Supposez par exemple que vous ayez écrit un programme de jeu de cartes. Vous avez décidé que votre application manipulerait un jeu de 32 cartes. Cette valeur restera immuable tout au long de lʼexécution. À cette fin, vous avez défini une constante : _sabot = 32. Si ultérieurement, pour une raison quelconque, vous décidez que votre application doit fonctionner avec un jeu de 54 cartes, vous nʼaurez plus quʼà changer la valeur de la constante et si votre programme a été bien conçu et écrit correctement, il continuera à fonctionner comme auparavant, mais en tenant compte de cette modification.

Une constante doit pouvoir être identifiée de manière unique par le compilateur, cela signifie que vous ne pouvez pas déclarer deux constantes portant le même nom dans votre programme; cette restriction, là encore, ne sʼapplique pas aux variables. On verra par la suite quelles sont les implications dʼune telle règle. Vous pouvez en revanche déclarer des constantes portant des noms différents mais se référant à la même valeur.

Sachez aussi que FutureBASIC^3 permet de déclarer des constantes de type chaîne de caractères, par exemple :

_maConstante$ = "Ceci est une constante chaîne"

Notez que les chaînes de caractères que vous entrez littéralement dans votre code source sont placées entre guillemets droits (ou double-primes ).

Il est important de savoir aussi, quʼen dehors des constantes que vous pouvez déclarer pour les besoins de votre programme, FutureBASIC reconnaît déjà une quantité impressionnante de constantes prédéfinies. Lʼenvironnement fournit d'emblée un jeu de constantes que vous pouvez utiliser sans avoir à les déclarer (la plupart de ces constantes sont utilisées pour passer des valeurs aux fonctions et aux commandes de FutureBASIC; vous verrez très vite qu'il est plus facile de se souvenir dʼun nom significatif que dʼune valeur numérique), il en va de même pour les constantes déclarées par Apple que vous pouvez utiliser dans les appels à la Toolbox et que vous trouverez identiques dans d'autres langages de programmation.

Le nom des constantes prédéfinies est en anglais. Cela peut sembler pénible pour des débutants, mais en réalité c'est une chance pour nous francophones. Les exemples sur le CD-ROM peuvent vous aider à vous y retrouver, car toutes les constantes-utilisateur (cʼest-à-dire définies par le programmeur) ont été traduites en français, tandis que celles propres à FutureBASIC ou à la Toolbox sont restées dans la langue de Shakespeare ou celle de Thomas Edison si vous préférez.

Bien entendu, vous pouvez, si vous le souhaitez, utiliser vos propres constantes comme paramètres aux fonctions prédéfinies de FutureBASIC ou de la Toolbox, les constantes nommées ne sont en réalité quʼun moyen facilement mémorisable pour désigner des valeurs. Par exemple, la constante prédéfinie nommée _zBlack représente la valeur 7, rien ne vous empêche, bien que cela ne soit pas vraiment conseillé, de définir une constante appelée _noir ayant la même valeur et de lʼutiliser en lieu et place de la constante _zBlack.

Il est très vivement conseillé de faire un usage immodéré des constantes nommées. Lorsqu'on débute, on a tendance à négliger cet aspect et on trouve plus facile de taper des nombres dans le code source que des constantes qui pourraient les remplacer avec la même efficacité. Mais, vous devez tenir compte de deux ou trois choses qui peuvent avoir une grande importance dans de gros programmes en ce qui concerne leur débogage (la correction des erreurs de programmation) et leur maintenance (évolution). D'abord, on a vite fait de faire une erreur de frappe en saisissant des nombres, mais vous penserez que c'est la même chose avec des constantes nommées. Ce n'est pas tout à fait vrai, car votre programme peut parfaitement sembler fonctionner si vous tapez un 8 à la place d'un 9 par exemple; le Compilateur ne bronchera pas, tandis que si vous faites une faute de frappe dans une constante nommée, il y a de très grandes chances que le Compilateur rouspète en vous signalant qu'il n'a jamais entendu parler de cette constante avant la ligne fautive et il refusera de la compiler. Maintenant, si vous vous projetez dans quelques années et que vous décidiez de reprendre le développement d'un programme que vous avez écrit à vos débuts, vous aurez peut-être beaucoup de difficultés à comprendre certaines sections de votre code remplies de chiffres les uns plus obscurs que les autres. En utilisant des constantes nommées, au contraire, vous lirez votre prose avec aisance, le code étant ainsi auto-documenté. Nous avons expliqué un troisième avantage à utiliser les constantes nommées dans notre exemple fictif d'un programme de jeu de cartes aussi nous n'y reviendrons pas. En résumé, vous bénirez le ciel d'avoir adopté cette pratique recommandée avec insistance.



[Precédent] [Table des Matières] [Suivant]

Profileur
Le Profileur est un outil destiné à mesurer les performances de votre code, il vous permet dʼévaluer lʼefficacité en terme de vitesse d'exécution de vos algorithmes.

Guillemets droits
Ces guillemets sont souvent appelés à tort guillemets anglo-saxons.

© 2000 Pix&Mix
Tous droits réservés

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