![[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 outils du programmeur |
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 Guillemets droits |
 |
||
 |
||
|
FutureBASIC est une marque déposée appartenant à Staz Software, Inc et utilisée avec permission. |
||