Chapitre 20 — Développement de véritables programmes
Nous arrivons à la fin de notre Guide pratique de programmation. Ce chapitre explique comment
écrire des programmes. Il n'introduit aucune commande
BASIC
nouvelle, mais il essaie de faire accepter l'une des méthodes les plus populaires d'écrire un programme.
Jusqu'à présent, nos programmes ont été de petites merveilles de 10 lignes conçus pour démontrer
les aspects individuels du langage. Chez les programmeurs, il y a une tendance à commencer petit, comme ceci,
et à construire une chose à la fois : ajouter deux lignes ici, une sous-routine là... Et bientôt
l'édifice tout entier devient une jungle enchevêtrée, difficile à parcourir et un terrain encore plus dur
à remettre en état et à agrandir.
Traditionnellement, la programmation était enseignée par des enseignants pour répartir les choses
en étapes logiques et progressives. C'est quelquefois si facile que vous ne le faites pas consciemment.
Par exemple, dans le chapitre sur les caractères définis par l'utilisateur, nous devons d'abord définir
le caractère représentant l'extraterrestre, avant de le faire marcher en travers de l'écran. Ça ne
servirait à rien de le faire dans l'autre sens. La conception d'un programme « convenable »
suit la même idée, mais à une échelle beaucoup plus grande. C'est tellement vrai qu'il peut se passer
des journées entières avant que nous ne commencions véritablement à taper du code. L'avis général est
qu'il faut vous concentrer d'abord sur les généralités, la vue d'ensemble, et puis
fractionner ces tâches en tâches progressivement plus petites jusqu'à ce qu'elles soient si petites
que le code en découle de lui-même.
C'est très facile de gesticuler en essayant, par des gestes généraux, de faire comprendre ce que
vous voulez dire, comme dans un mime. Pour éviter cela, je tiens à parcourir la conception d'un véritable
programme, en expliquant chacun des pas à mesure que nous avançons, de telle sorte que vous puissiez
appliquer cette démarche à vos propres créations. On appelle souvent ce procédé le développement
« de haut en bas ». C'est une technique courante utilisée
par de nombreux programmeurs, et pas quelque chose que j'ai imaginé après trois nuits de lecture
des romans du cyberpunk cybernétique
William Gibson.
Si les programmeurs utilisent cette méthode, c'est qu'elle s'adapte facilement à différents langages
et qu'elle donne de bons résultats – c'est-à-dire qu'elle marche.
Si nous prenons les caractères définis par l'utilisateur, nous voyons qu'ils sont très utiles.
Ce qui peut être ingrat, c'est de tracer la grille et faire le calcul mental pour en tirer les totaux
nécessaires sur les diverses lignes. Un Générateur de caractères me semble
être un bon candidat pour l'écriture d'un programme.
1.– Commencer en « pseudo-code »
Comment commencer ?
Il existe un langage très relâché, le pseudo-code, dont la définition exacte est
quelque peu vague, parce que chacun a tendance à développer le sien propre. Cela ressemble généralement
à un mélange de langue standard avec quelques mots de
BASIC
jetés au milieu. Ce qu'il représente, c'est la suite logique des événements nécessaires pour exécuter
la tâche à accomplir.
Nous commençons avec la vue d'ensemble. Par là, je suggère que nous divisions les tâches
que notre programme doit prendre en charge en grands morceaux, chacun pouvant être résumé
en une ligne de quelques mots.
Voici de quoi cela a l'air :
Déclarer tableaux globaux et les structures
Initialisation
Dessiner l'écran principal
Dessiner le caractère
Dessiner le curseur
REPEAT
Intercepter l'action de l'utilisateur
Traiter l'action de l'utilisateur
UNTIL L'utilisateur choisit de sortir
Fermeture
END
C'est l'organisation de base de notre programme. Comme vous le voyez, rien n'est spécifié :
tout est attribué à des sous-tâches.
2.– Affiner les sous-tâches
L'étape suivante consiste à prendre chacune de ces sous-tâches et à les affiner de façon
similaire. Laissons pour l'instant de côté les deux premières lignes, parce que nous n'avons dans ces
prémices aucune idée des variables dont nous aurons besoin ni de la façon de les initialiser.
a.– Dessiner l'écran principal
Commençons avec la partie Dessiner l'écran principal.
Pour ce faire, il nous faut une grossière idée de ce qu'il faudra présenter à l'utilisateur
lorsque le programme tournera. Faisons d'abord un schéma sur le papier, en utilisant éventuellement
du papier quadrillé si l'on veut avoir une meilleure idée des dimensions.
Voici ce à quoi nous voulons aboutir :
+--------------------------------------------------+
| Générateur de Caractères |
| ************************ |
| |
| Instructions |
| Utiliser flèches pour déplacer le curseur |
| Espace pour alterner la cellule choisie |
| Appuyer sur X ou ESC pour finir |
| |
| |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| [][][][][][][][] 000 |
| |
| * * * * * * * * |
| |
| Code BASIC pour produire ce caractère : |
| |
| VDU 23,240,000,000,000,000,000,000,000,000 |
| |
| |
+--------------------------------------------------+
La moitié supérieure de l'écran est ce que j'appellerai l'écran principal : elle ne
changera pas beaucoup au cours du programme. La partie inférieure contient la grille,
les codes VDU et les caractères grandeur nature. Cette partie changera beaucoup, aussi
la conception doit traiter cela séparément. La rangée d'astérisques sous la grille représente une rangée
de caractères véritables. Il nous apparaît immédiatement que la ligne VDU est plus longue que les
40 caractères que nous donne le
MODE
6, aussi devrons-nous choisir un autre mode pour pouvoir la contenir. Le
MODE
21 nous donne 50 colonnes, ce qui devrait suffire. Nous en savons maintenant assez pour
pouvoir établir ce à quoi doit ressembler Dessiner l'écran principal.
Dessiner l'écran principal
Fixer la couleur de fond
CLS
PRINT Titre
PRINT aide instructions
END
C'est
CLS
qui est utilisé en lieu et place de « Vider l'écran » parce qu'il est évident
que c'est la commande qu'il faut.
b.– Dessiner le caractère
Il n'y a ici pas grand chose à faire ; ce qui suit promet d'être un défi un peu plus grand :
Dessiner le caractère. On peut envisager de considérer qu'il y a trois parties
distinctes : la grille, le caractère lui-même et les codes
VDU.
En restant dans le général, voici ce que nous obtenons.
Dessiner le caractère
Tracer la grille
Dessiner le caractère réel
Afficher les codes VDU
END
Il est parfaitement évident qu'il y a ici davantage de travail à faire, mais c'est notre première
mouture, aussi laisserons-nous les détails pour plus tard. Au cours de la conception, les choses
changent souvent, aussi cela ne sert à rien de trop s'impliquer à ce niveau.
c.– Dessiner le curseur
Vient ensuite : Dessiner le curseur. On s'en servira pour déplacer
le curseur dans la grille. Pour qu'on ait l'impression que le curseur se déplace, nous devons d'abord
l'effacer de son ancienne position puis le redessiner à la nouvelle. Nous pouvons utiliser une couleur
différente pour mettre le curseur en relief quand il se déplace sur la grille, et pour ce, nous devons
savoir si la cellule sur laquelle il se trouve est à 1 ou à 0.
Dessiner le curseur
Mettre à la couleur normale
Effacer le curseur à l'ancienne position
Mettre la couleur curseur en relief
Colorer la cellule à la position actuelle
END
d.– Intercepter l'action de l'utilisateur
Maintenant, nous plongeons dans la boucle
REPEAT
et nous y trouvons Intercepter l'action de l'utilisateur.
Cette partie aura pour charge d'intercepter les touches tapées au clavier, en filtrant celles que nous
ne voulons pas et en traduisant les autres en code pour que le reste du programme s'en serve.
D'après notre schéma d'écran, nous déduisons que les touches qui nous intéressent sont les
touches fléchées, la barre d'espacement et le « X »
ou le « x ». L'utilisation de
Esc
pour sortir est une caractéristique intrinsèque, aussi n'avons-nous pas besoin de nous en occuper
en tant que telle. Le programme peut rester à attendre qu'une touche soit pressée puisque toutes
les autres actions dépendent de cela. Quand une touche est pressée, nous pouvons décider si elle est
utile ou non et si elle l'est, la traduire en un code.
Intercepter l'action de l'utilisateur
REPEAT
Attendre qu'une touche soit pressée
Traduire en code si la touche est valide
UNTIL interception de touche valide
END
e.– Traiter l'action de l'utilisateur
En dernier lieu pour le moment, nous avons Traiter l'action de l'utilisateur.
Ici, on prendra l'action de la routine précédente et on en fera quelque chose. Les options sont très
évidentes, aussi pouvons-nous sans plus tarder écrire ce qui suit.
Traiter l'action de l'utilisateur
CASE Code OF
WHEN Haut : Déplacer curseur vers le haut
Dessiner le curseur
WHEN Droite : Déplacer curseur à droite
Dessiner le curseur
WHEN Bas : Déplacer curseur vers le bas
Dessiner le curseur
WHEN Gauche : Déplacer curseur à gauche
Dessiner le curseur
WHEN Sortie : Mettre drapeau de Sortie à 1
ENDCASE
END
f.– L'ensemble du premier passage
Voilà : c'était notre premier passage. Mettons tous les morceaux ensemble pour le voir
en un seul endroit.
Programme principal
Déclarer tableaux globaux et les structures
Initialisation
Dessiner l'écran principal
Dessiner le caractère
Dessiner le curseur
REPEAT
Intercepter l'action de l'utilisateur
Traiter l'action de l'utilisateur
UNTIL L'utilisateur choisit de sortir
Fermeture
END
Dessiner l'écran principal
Fixer la couleur de fond
CLS
PRINT Titre
PRINT aide instructions
END
Dessiner le caractère
Tracer la grille
Dessiner le caractère réel
Afficher les codes VDU
END
Dessiner le curseur
Mettre à la couleur normale
Effacer le curseur à l'ancienne position
Mettre la couleur curseur en relief
Colorer la cellule à la position actuelle
END
Intercepter l'action de l'utilisateur
REPEAT
Attendre qu'une touche soit pressée
Traduire en code si la touche est valide
UNTIL interception de touche valide
END
Traiter l'action de l'utilisateur
CASE Code OF
WHEN Haut : Déplacer curseur vers le haut
Dessiner le curseur
WHEN Droite : Déplacer curseur à droite
Dessiner le curseur
WHEN Bas : Déplacer curseur vers le bas
Dessiner le curseur
WHEN Gauche : Déplacer curseur à gauche
Dessiner le curseur
WHEN Bascule :Intervertir position grille
WHEN Sortie : Mettre drapeau de Sortie à 1
ENDCASE
END
Si vous vous êtes jamais senti intimidé à la pensée d'écrire un programme de taille raisonnable comme
celui-ci, j'espère que vous voyez maintenant comment nous commençons à le débiter en morceaux de toute
petite taille comme ceux sur lesquels vous vous êtes habitué à travailler jusqu'ici.
3.– Deuxième passage (2e affinage)
Plusieurs des routines semblent pouvoir être encore affinées. Ce sont
Dessiner le caractère et
Traiter l'action de l'utilisateur.
a.– Tracer la grille
Dessiner le caractère a trois lignes qui doivent faire réfléchir.
La première dit Tracer la grille. Le tracé de la grille comprend aussi
les totaux de lignes au bout de chacune d'elles. Nous avons là besoin de décider si le tracé de la grille
et le calcul des sommes de lignes auront besoin de suffisamment de code pour mériter leur propre routine,
ou bien les mettrons-nous dans la routine actuelle sans la surcharger ? Il est à présent devenu évident
qu'il nous faudra un tableau pour contenir la grille. Pour tracer la grille, nous utiliserons
une position d'écran pour chaque cellule, pour n'avoir ensuite rien d'autre à faire que suivre
chaque ligne et chaque colonne pour afficher tour à tour le caractère correct. Comme nous sommes déjà
bien impliqués dans la grille, il semble raisonnable de prévoir également ici les totaux de lignes.
Pour chaque rangée, ou ligne, nous devons mettre le total à zéro, et ensuite, lorsque nous trouvons
une position de grille qui est à 1, ajouter au total la valeur de cette colonne.
Si nous fixons une valeur à 128 et que nous la divisions par deux à chaque colonne,
nous pouvons en déduire la valeur pour cette colonne.
Tracer grille & calculer chaque total ligne
FOR chaque ligne
Mettre la valeur de colonne à 128
FOR chaque colonne
Mettre le total de ligne à 0
IF Grille à posit.ligne col. = 0 THEN
PRINT à posit. caract. cellule vide
ELSE
PRINT à posit. caract. cellule pleine
Mettre tot.ligne à tot.ligne+val.col.
ENDIF
Mettre valeur colonne à val. colonne / 2
NEXT colonne
PRINT au bout de la ligne le total de ligne
NEXT ligne
b.– Dessiner le caractère réel
Personnellement, je pense que cela ira très bien dans la routine existante, aussi n'est-il pas besoin
d'en faire une nouvelle. Disséquons la ligne suivante :
Dessiner le caractère réel. Nous avons déjà trouvé les valeurs
pour chaque ligne dans le bloc de code précédent, aussi est-ce maintenant très facile.
Appeler VDU 23 avec car. 240 & totaux lignes
PRINT à sa position huit fois le car. 240
Il nous faut enfin afficher les totaux sur une ligne bien faite pour que les utilisateurs
puissent les recopier dans leurs programmes.
PRINT à posit. "Code BASIC pour ce carac. :"
PRINT à sa position "VDU 23, 240";
FOR chaque ligne
PRINT ",";total de la ligne;
NEXT ligne
L'intégralité de notre routine ressemble ainsi à ceci :
Dessiner le caractère
Tracer grille & calculer chaque total ligne
FOR chaque ligne
Mettre la valeur de colonne à 128
FOR chaque colonne
Mettre le total de ligne à 0
IF Grille à posit.ligne col. = 0 THEN
PRINT à posit. caract. cellule vide
ELSE
PRINT à posit. caract. cellule pleine
Mettre tot.ligne à tot.ligne+val.col.
ENDIF
Mettre valeur colonne à val. colonne / 2
NEXT colonne
PRINT au bout de la ligne le total de ligne
NEXT ligne
Appeler VDU 23 avec car.240 & totaux lignes
PRINT à sa position huit fois le car. 240
PRINT à posit. "Code BASIC pour ce carac. :"
PRINT à sa position "VDU 23, 240";
FOR chaque ligne
PRINT ",";total de la ligne;
NEXT ligne
END
Vous voyez comment nous avons fait pour conserver les descriptions originales des tâches ?
Celles-ci deviennent habituellement des
REM
dans le programme terminé, parce qu'elles indiquent au lecteur le but que chacune des sections
essaie d'atteindre.
c.– Traiter l'action
Passons à Traiter l'action.
Ici, il y a deux choses à voir.
• La première,
c'est une petite restructuration. Chaque action implique de redessiner le curseur, aussi sans doute
devrions-nous sortir cette action de chaque instruction et la déplacer à la fin, pour économiser la place
et le temps de frappe. C'est assez facile, parce que nous n'avons pas encore écrit de code.
• La seconde, c'est l'utilisation du déplacement du curseur. Nous nous trouvons
à nouveau devant un choix : faire une routine séparée ou bien écrire le code à chaque endroit.
J'ai choisi la première option parce que nous pouvons alors écrire une routine générique pour manipuler
tout mouvement du curseur. Nous pouvons noter cela, et nous définirons la routine dans un instant.
Entre temps, y a-t-il autre chose ? Nous ne nous sommes pas occupés de ce qui se passe dans le cas
où l'on tape sur la barre d'espacement. En réalité, ce n'est pas trop une grosse difficulté :
WHEN Bascule : Intervertir position grille
IF Grille à curseur = 0 THEN
Mets Grille posn.curseur à 1
ELSE
Mets Grille posn.curseur à 0
ENDIF
Tout ce qu'il nous faut faire, c'est de mettre la grille à jour.
Dessiner le caractère dans le programme principal se débrouillera
pour faire le reste. Voici notre routine Traiter l'action révisée :
Traiter l'action de l'utilisateur
CASE Code OF
WHEN Haut : Déplacer curseur vers le haut
WHEN Droite : Déplacer curseur à droite
WHEN Bas : Déplacer curseur vers le bas
WHEN Gauche : Déplacer curseur à gauche
WHEN Bascule :Intervertir position grille
IF Grille position ligne colonne = 0 THEN
Mets Grille posit. du curseur à 1
ELSE
Mets Grille posit. du curseur à 0
ENDIF
WHEN Sortie : Mettre drapeau de Sortie à 1
ENDCASE
Dessiner le curseur
END
d.– Déplacer le curseur
Après tout cela, nous pouvons retourner à notre routine de déplacement du curseur.
Tout ce qu'il faut ici, c'est prendre la direction dans laquelle le curseur veut se déplacer et vérifier
que c'est une position valide, c'est-à-dire qu'elle ne se situe pas en dehors de la grille.
Si la position est dûment vérifiée, déplacez-y le curseur. Avant de le déplacer, nous devons
nous souvenir de la position antérieure pour que
Dessiner le curseur puisse l'effacer avant de mettre la nouvelle
position à la couleur de curseur en relief.
Déplacer le curseur
Enregistrer posit.actuelle ds ancienne posit.
CASE Direction OF
WHEN Haut : IF ligne Curseur > 1 THEN
Diminuer ligne Curseur de 1
WHEN Droite : IF colonne Curseur < 8 THEN
Augm. colonne Curseur de 1
WHEN Bas : IF ligne Curseur < 8 THEN
Augm. ligne Curseur de 1
WHEN Gauche : IF colonne Curseur > 1 THEN
Diminuer col. Curseur de 1
ENDCASE
END
e.– La Version 2 du « pseudo-programme »
La Version 2 de notre conception de programme est maintenant comme ceci :
Programme principal
Déclarer tableaux globaux et les structures
Initialisation
Dessiner l'écran principal
Dessiner le caractère
Dessiner le curseur
REPEAT
Intercepter l'action de l'utilisateur
Traiter l'action de l'utilisateur
UNTIL L'utilisateur choisit de sortir
Fermeture
END
Dessiner l'écran principal
Fixer la couleur de fond
CLS
PRINT Titre
PRINT aide instructions
END
Dessiner le caractère
Tracer grille & calculer chaque total ligne
FOR chaque ligne
Mettre la valeur de colonne à 128
FOR chaque colonne
Mettre le total de ligne à 0
IF Grille à posit.ligne col. = 0 THEN
PRINT à posit. caract. cellule vide
ELSE
PRINT à posit. caract. cellule pleine
Mettre tot.ligne à tot.ligne+val.col.
ENDIF
Mettre valeur colonne à val. colonne / 2
NEXT colonne
PRINT au bout de la ligne le total de ligne
NEXT ligne
Appeler VDU 23 avec car. 240 & totaux lignes
PRINT à sa position huit fois le car. 240
PRINT à posit. "Code BASIC pour ce carac. :"
PRINT à sa position "VDU 23, 240";
FOR chaque ligne
PRINT ",";total de la ligne;
NEXT ligne
END
Dessiner le curseur
Mettre à la couleur normale
Effacer le curseur à l'ancienne position
Mettre la couleur curseur en relief
Colorer la cellule à la position actuelle
END
Intercepter l'action de l'utilisateur
REPEAT
Attendre qu'une touche soit pressée
Traduire en code si la touche est valide
UNTIL interception de touche valide
END
Traiter l'action de l'utilisateur
CASE Code OF
WHEN Haut : Déplacer curseur vers le haut
WHEN Droite : Déplacer curseur à droite
WHEN Bas : Déplacer curseur vers le bas
WHEN Gauche : Déplacer curseur à gauche
WHEN Bascule :Intervertir position grille
IF Grille à curseur = 0 THEN
Mets Grille posn.curseur à 1
ELSE
Mets Grille posn.curseur à 0
ENDIF
WHEN Sortie : Mettre drapeau de Sortie à 1
ENDCASE
Dessiner le curseur
END
Déplacer le curseur
Enregistrer posit.actuelle ds ancienne posit.
CASE Direction OF
WHEN Haut : IF ligne Curseur > 1 THEN
Diminuer ligne Curseur de 1
WHEN Droite : IF colonne Curseur < 8 THEN
Augm. colonne Curseur de 1
WHEN Bas : IF ligne Curseur < 8 THEN
Augm. ligne Curseur de 1
WHEN Gauche : IF colonne Curseur > 1 THEN
Diminuer col. Curseur de 1
ENDCASE
END
Est-ce que ça n'est pas merveilleux d'utiliser copier-coller ?
Pour trouver les variables
La conception du projet a atteint un point à partir duquel vous pouvez commencer à
« voir » le code sous-jacent, c'est-à-dire que nous l'avons assez affiné.
C'est maintenant le moment d'inviter les amis et la famille autour de la table pour jouer à
« chassez la variable ».
À ce point, je prends normalement un stylo rouge et je gribouille le pseudo-code.
C'est un peu difficile à faire dans le Bloc-notes ou dans Internet Explorer,
aussi nous allons faire une analyse détaillée de chaque routine. Heureusement, cela ne prendra pas
autant de temps que la partie précédente. Pour chaque routine, nous devons connaître le nom,
le type et le scope de chaque variable à trouver.
En parcourant le programme principal, nous voyons deux variables qui surgissent.
L'une est le drapeau (flag) utilisé pour Sortir (Exit), l'autre le choix de l'action
dans la routine Intercepter l'action de l'utilisateur.
Toutes deux sont des entiers et par le fait même qu'elles se situent dans le programme principal,
elles sont globales. La variable de Sortie devra être mise à « faux »
quand le programme est lancé, aussi cela concerne-t-il la routine d'initialisation.
Dessiner l'écran principal n'a aucune variable, puisque ce n'est
que de l'affichage. Facile !
Dessiner le caractère est un peu plus complexe.
Nous aurons besoin de deux variables locales entières pour les boucles
FOR,
et nous les appellerons Ligne% et Col%.
Un autre entier est nécessaire pour la valeur de chaque bit ; appelons-le ValeurCol% :
là aussi, rien d'autre n'a besoin de s'en servir, aussi est-il local.
Les données du caractère principal lui-même, à l'évidence, sont conservées dans un tableau à deux dimensions.
Nous l'appellerons Grille% et il est global parce que les autres routines ont besoin d'y accéder.
Un autre tableau est nécessaire pour contenir les totaux de lignes : TtalLigne%.
Ce sera un tableau à une seule dimension pour des entiers.
Là encore, nous le ferons global.
Dessiner le curseur semble avoir quatre entiers associés aux positions actuelle et précédente du curseur.
Ce serait bien de les stocker ensemble, aussi mettons-les dans une structure.
La structure doit être globale puisque nous savons que la routine
Déplacer le curseur l'utilise également.
Tous sont des entiers et la position initiale sera définie dans la routine d'initialisation.
Intercepter l'action de l'utilisateur
a une variable entière pour contenir la touche pressée, Touche%, et une variable entière
pour contenir le code renvoyé, Code%.
Les deux sont locales.
Traiter l'action de l'utilisateur peut avoir la valeur du code
de l'action qui lui est passé.
Le drapeau Sortie est global comme cela a déjà été décrit.
Déplacer le curseur manipule la structure du curseur comme décrit
dans Dessiner le curseur.
Il faut considérer quelques autres détails. Par exemple, la position de chaque instruction
PRINT
doit être décidée. On peut deviner cela grossièrement en considérant la disposition de l'écran,
mais sachez-le : vous n'y arriverez jamais exactement du premier coup !
La grille de 8 × 8
Nous n'avons pas encore considéré la façon dont nous allons représenter la grille.
Chaque position peut être décrite comme la position d'un caractère.
Si elle est occupée, nous pouvons utiliser un bloc intégral.
Si elle est vide, c'est l'espace qui semblerait le caractère le plus évident.
Pourtant, si nous utilisons l'espace, comment savoir où se trouve le curseur ?
Il nous faut également un caractère pour une cellule vide. Un caractère ayant un contour d'un seul bit suffira.
Donc, il nous faut deux caractères définis par l'utilisateur :
XXXXXXXX 255 XXXXXXXX 255
XXXXXXXX 255 X......X 129
XXXXXXXX 255 X......X 129
XXXXXXXX 255 X......X 129
XXXXXXXX 255 X......X 129
XXXXXXXX 255 X......X 129
XXXXXXXX 255 X......X 129
XXXXXXXX 255 XXXXXXXX 255
où « X » = rempli et
« . » = vide.
Les caractères 241 et 242 iront très bien pour cela.
C'est à la routine d'initialisation qu'il appartient de les mettre en place.
L'initialisation et la fermeture
À l'aide de tous ces renseignements, nous pouvons dès lors écrire la routine d'initialisation...
Initialisation
Définir le mode graphique
Définir caract. utilisateur 240, 241 et 242
Définir l'emplacement du curseur
Éteindre le curseur de texte
END
...et en dernier lieu, son complément, Fermeture, dont le travail sera de faire
le nettoyage avant l'arrêt du programme. Nous ne voulons pas vider l'écran ici, parce qu'il se pourrait
que l'utilisateur veuille prendre note de sa nouvelle création après la fin du programme.
Nous nous contenterons de rallumer le curseur de texte et de le placer en bas de l'écran pour qu'il ne soit
pas une gêne.
Fermeture
Rallumer le curseur de texte
Placer le curseur au bas de l'écran
END
Le Programme
Enfin, nous voici dans la situation où nous pouvons écrire le code.
Comme vous l'avez sans doute maintenant deviné, chaque tâche comme
Dessiner le curseur doit être maintenue séparée du corps de code principal.
Pour y parvenir, nous utilisons des
PROC et des
FN.
Je ne vais pas vous en faire un compte-rendu ligne par ligne parce que, si vous avez suivi
tout ce qui précède, il n'existe rien qui puisse vous choquer ni vous étonner.
Cliquez sur le lien vers le programme complet. J'aime laisser des lignes en blanc
pour rendre les choses plus faciles à lire.
Également, chaque tâche est séparée d'une autre par une ligne d'astérisques
et une petite description, pour la rendre plus facile à retrouver lorsque vous parcourez l'ensemble du code.
Je sais que j'ai dit au tout début que vous devriez taper vous-même tout le code à la main,
aussi veuillez vous sentir libre de le faire, mais simplement au cas où ça vous démange de voir
à quoi ressemble votre création achevée, vous avez là une gentille version à copier et coller.
Cliquez sur le lien ci-dessous et puis, si vous êtes dans
Internet Explorer™,
cliquez sur le menu Edition, puis Sélectionner tout, puis de nouveau Edition
et enfin Copier.
Vous pouvez alors coller l'ensemble dans l'éditeur.
Si vous utilisez un autre navigateur, il y a sans doute une méthode similaire qui s'y cache quelque part.
Utilisez la flèche de retour arrière dans votre navigateur pour revenir ici quand vous aurez vu le programme.
Listing du programme principal
Conclusion
Et voilà notre programme.
Pas trop mal, n'est-ce pas ?
Le problème, en l'ayant écrit comme ceci, c'est qu'il apparaît comme un processus entièrement linéaire.
Ce n'est pas le cas. Souvent, le pseudo-code subira un certain nombre de révisions avant de s'établir
comme version finale. Et même alors, en affectant des variables ou en écrivant du code,
vous rencontrerez des situations qui exigent de revenir en arrière et de remanier quelque chose.
Loin d'être une perte de temps, c'est le meilleur moyen de développer un programme. Pourquoi ?
Simplement parce que plus vous prenez le temps de vous asseoir et de réfléchir à quelque chose,
en ruminant les différentes façons de le faire, plus vous aurez de chances de le faire correctement.
Si vous aviez une entrevue ou un rendez-vous important, vous ne laisseriez pas au hasard
le soin de trouver votre chemin vers votre destination, sans planifier l'itinéraire.
Alors, comment pourriez-vous espérer écrire un programme décent si vous ne faites que
retrousser vos manches pour commencer à taper ?
Si vous faisiez cela, après avoir tapé votre programme il vous semblera plus facile d'essayer
de tripoter les morceaux qui ne se comportent pas correctement plutôt que de revenir sur vos pas
et d'admettre que vous aviez un peu plus tôt pris la mauvaise décision.
Si vous n'aviez pas planifié le programme, vous n'avez pas à revenir sur vos pas
et où que vous vous tourniez, vous êtes dans les sables mouvants.
Si vous aviez bel et bien fait une planification, il y a tout à croire qu'avec un peu d'expérience
vous auriez reconnu les problèmes au cours de votre approche et que vous les auriez éliminés
avant même d'en arriver à l'étape du codage. Comme je l'ai dit plus haut, aucune des idées exprimées ici
n'est nouvelle ni ne m'appartient. Je n'ai aucun intérêt financier à vous pousser vers cette méthode ;
simplement, on me l'a enseignée au début de ma carrière et je l'ai utilisée en
Pascal, en
C
ou
C++
et en
VB ou
VBA .
Oh ! et en
BBC BASIC, aussi.
Et des centaines d'autres programmeurs l'ont fait aussi.
Utilisez-la. Elle marche. (Fin de déclamation.)
Exercices
20.1
Je suis certain que vous verrez ici un grand nombre d'améliorations ; essayez d'ajouter deux autres
commandes, l'une pour vider complètement la grille et l'autre pour la remplir. Vous pourriez utiliser
V et R pour faire cela. Remarquez combien il est facile d'écrire le code pour des
modifications comme celles-ci, parce que la structure rend tout facile à trouver.
20.2
Il est également agréable de pouvoir travailler dans l'autre sens, en établissant les caractères
à partir des totaux de lignes. Modifiez le projet pour permettre à l'utilisateur d'entrer un total
pour la ligne sur laquelle il se trouve. Ensuite, réaffichez le caractère.
Fin du Chapitre 20
|
Chapitre 19
Chapitre 21
Haut de Page • [Top of Page]