CyBWarrior » QBasic

QBasic – Le clavier

25/03/2002 cybwarrior 3 commentaires

This entry is part 30 of 30 in the series QBasic - Tutoriel

INKEY$
L’interception d’évenements

On a déjà vu que l’on peut à tout moment connaitre l’état d’une touche du clavier avec INKEY$.
Pour ceux qui n’auraient pas suivis à ce moment là, petit rappel.

INKEY$

L’instruction INKEY$ renvoi une chaîne de caractère contenant l’état du clavier.

Si aucune touche n’est enfoncée, INKEY$ renvoi une chaîne vide.

Si l’utilisateur presse une touche au moment de l’appel de INKEY$, le carctère frappé est
renvoyé. C’est à dire que si par exemple, l’utilisateur appui sur la touche ‘P’ alors que
le verouillage majuscule est activé, INKEY$ renvera un P majuscule. Au contraire, si le
verouillage est inactif, ce sera un p minuscule. Cette remarque est également
valable pour le pavé numérique.

Grâce à INKEY$, on peut facilement suspendre l’execution d’un programme jusqu’à l’appui sur une
certaine touche par l’utilisateur.

Exemple :



PRINT « Appuyez sur une touche pour continuer »

DO

LOOP UNTIL LEN(INKEY$)        ‘ Variante avec LEN(INKEY$) au lieu de INKEY$ <> «  »

L’interception d’évenements

QBasic ne s’arrête pas là avec le clavier. En effet, il possible de traiter les évenements en
provenance du clavier avec une structure semblable à celle étudiée précédement avec la manette
de jeu ou avec la minuterie.

Déja, on peut commencer par affecter une procédure à une touche de fonction. Vous savez, ce sont
les touches situées en haut du clavier : F1, F2…F12.

Pour préciser le sous-programme à executer par chaque touche, on utilise la structure suivante :



ON KEY(numero%) GOSUB Sousprogramme

numero% représente le numéro de la touche de fonction à associer à la procédure.
Le numéro 1 représente la touche F1; le 2, la F2 etc… jusqu’à F10. Pour F11 et F12, lire plus
loin.

Dans notre exemple, on va se limiter à l’utilisation des touches F1 et F2. La première va nous
servir à ouvrir un fichier, et la deuxième à quitter le programme.

ON KEY(1) GOSUB Lire ‘ Assignation du sous programme aux touches
ON KEY(2) GOSUB Quitter
KEY(1) ON ‘ Activation de la touche
KEY(2) ON

DO ‘ On rentre dans une boucle sans fin
LOOP

Lire: ‘ Lecture du fichier
CLS
INPUT « Entrez le nom et le chemin du fichier à ouvrir : « , Fichier$

CLS
PRINT Fichier$
PRINT
OPEN Fichier$ FOR INPUT AS #1
DO
LINE INPUT #1, Texte$
PRINT Texte$
LOOP UNTIL EOF(1) = – 1
CLOSE #1
RETURN

Quitter: ‘ Quitter
END
RETURN

Comme pour la manette de jeu et les minuteries, il ne faut pas oublier d’activer les touches
avec KEY ON. Bien entendu, KEY STOP et KEY OFF existent et ont le même emplois :

KEY OFF désactive l’intercéption d’évenements pour la touche précisée.

KEY STOP stoppe de façon provisoire l’intercéption d’évenements. Toute fois, si la
touche est préssée après l’appel de KEY STOP, les sous-programmes correspondants sont quand
même executés lors de la réactivation de la touche avec KEY ON.

Ce petit programme de lecture de fichier est bien, mais on peut mieux faire. Comment ? Et bien
en affichant un petit menu en bas de l’écran avec le récapitulatif des commandes associées à chaque
touche. Pour cela, il nous faut d’abord affecter une chaîne de caractère à chaque touche utilisée.
La syntaxe est :



KEY Numero%, Texte$

Où Numero% représente la touche de fonction et Texte$ la chaîne de caractère.
Ensuite, il faudra afficher le menu. Et là, rien de plus simple, on utilise KEY ON. Au
final, notre programme complet sera :

ON KEY(1) GOSUB Lire ‘ Assignation du sous programme aux touches
ON KEY(2) GOSUB Quitter
KEY(1) ON ‘ Activation de la touche
KEY(2) ON

KEY 1, « Lire un fichier » ‘ Affectation d’un texte au touche de fonction
KEY 2, « Quitter »

KEY ON ‘ Affichage du menu

DO ‘ On rentre dans une boucle sans fin
LOOP

Lire: ‘ Lecture du fichier
CLS
INPUT « Entrez le nom et le chemin du fichier à ouvrir : « , Fichier$

CLS
PRINT Fichier$
PRINT
OPEN Fichier$ FOR INPUT AS #1
DO
LINE INPUT #1, Texte$
PRINT Texte$
LOOP UNTIL EOF(1) = – 1
CLOSE #1
RETURN

Quitter: ‘ Quitter
END
RETURN

Lors de l’execution du programme vous remarquer que l’affichage des textes est limité à 6 caractères
maximum.

Vous remarquez aussi que le menu n’est pas éffacé, même lors de l’appel à CLS.

Si on avez voulu masquer le menu, on aurrait fait appel à KEY OFF.

Petite chose : les touches F11 et F12 ne sont pas associées aux touches 11 et 12, mais respectivement
au touches numéros 30 et 31.

Mais alors qu’elles touchent peuvent bien représenter les numéros à partir de 11 ?

11, flêche HAUT

12, flêche GAUCHE

13, flêche DROITE

14, flêche BAS

Ensuite, de 15 jusqu’à 25, ce sont des touches qui peuvent être définies par l’utilisateur. Ça
peut dans certains cas (les jeux ?) s’averer bien pratique.

Pour définir une touche, on procéde ainsi :

D’abord, on choisi un numéro libre.

Si on veut qu’une touche soit associée à une certaine combinaison, par exemple avec ALT
pour activer un menu plus élaboré que celui vu ci-dessus, il faut utiliser le code ASCII
approprié :
- CHR$(0) : aucune touche n’est associée
- CHR$(1) : touche majuscule gauche
- CHR$(3) : touche majuscule droite
- CHR$(4) : touche Control (CTRL)
- CHR$(8) : touche ALT
- CHR$(32) : vérouillage minuscule
- CHR$(64) : vérouillage majuscule

Pour finir, grâce au précieux tableau des codes de balyage clavier inclu dans l’aide en
ligne de QBasic, on regarde le code de la touche choisie.

Maintenant, on combien c’est trois étapes et on écrit :



KEY Numero%, CHR$(Combinaison%) + CHR$(Balayage%)

Pour affecter un évenement à la touche P, dont le code de balayage est 25, sans combinaison de
touche, on va donc écrire :

KEY 15, CHR$(0) + CHR$(25) ‘ Définition de la touche
ON KEY(15) GOSUB Boom ‘ Affectation du sous programme ‘Bug’ à la touche P
KEY(15) ON ‘ Activation de la touche

PRINT « Appuyez sur la touche P pour entendre un Boom »
DO
LOOP

Boom: ‘ ET boom !
SOUND 37, 5
END
RETURN

Il faut que le verouillage numérique et majuscules soit inactif pour que cet exemple fonctionne.

Categories: QBasic Tags:

QBasic – Le texte

25/03/2002 cybwarrior 7 commentaires

This entry is part 14 of 30 in the series QBasic - Tutoriel

LOCATE
CSRLIN
POS
VIEW PRINT
PRINT USING
LEN, LEFT$, RIGHT$, MID$
La table de caractères ASCII
Espaces et tabulations
L’instruction STRING$
LTRIM$ et RTRIM$
La casse…

Vous savez déjà qu’il est très aisé d’afficher du texte avec QBasic, grâce à l’instruction
PRINT. Mais vous êtes bien loin d’imaginer les fabuleuses possibilités de traiter le texte avec
Basic.

LOCATE

L’instruction LOCATE permet de positionnez le curseur à un endroit choisi par le programmeur.
Curieusement, lorsqu’on l’utilise, il faut spécifier d’abord les Y, puis les X. Par exemple,
pour écrire ‘Hello, It’s me !‘ à la 5 ligne et à la 15 colonne, il faudra écrire :



LOCATE 15, 5

PRINT « Hello, It’s me ! »

Si on veut, on peut afficher ou pas le curseur en écrivant 1 ou 0 en troisième argumant :



LOCATE 15, 5, 1′ Appuyez sur une touche pour continuer_

PRINT « Hello, It’s me ! »

On peut aussi définir la hauteur de ce curseur (très peut utilisé) grâce au quatrième et
cinquième argument.



LOCATE 15, 5, 1, 0, 31′ Le curseur est un carré

PRINT « Hello, It’s me ! »

CSRLIN

Cette instruction retourne le numéro de la ligne où se trouve le curseur :



LOCATE 15, 5, 1, 0, 31′ Le curseur est un carré

PRINT « Hello, It’s me ! »

PRINT « Le curseur est sur la ligne « ; CSRLIN

POS

POS renvoi le numéro de la colonne où se trouve le curseur. Curieusement, il faut
écrire un nombre quelconque dans les parenthèses suivant POS.



LOCATE 15, 5, 1, 0, 31′ Le curseur est un carré

PRINT « Hello, It’s me ! »

PRINT « Le curseur est sur la ligne « ; CSRLIN

PRINT « Le curseur est sur la colonne « ; POS(0)’ On a écrit 0, mais on aurrait pu

‘ écrire 666

VIEW PRINT

VIEW PRINT permet de redimensionner la fenêtre texte. On indique la première ligne,
puis la deuxième, avec TO entre les deux :



CLS

VIEW PRINT 5 TO 15

PRINT « Ce texte est écrit sur la première ligne de la fenêtre texte »

PRINT USING

PRINT USING affiche un texte (ou un nombre) suivant un format spécifié. Il vous faut
pour cela vous référer au tableau suivant :

FORMATAGE D’UNE EXPRESSION NUMERIQUE
Caractères	Effet
#	Position d’un chiffre
.	Positon du point décimal
,	Doit être placée à gauche du point décimal. Il affiche une virgule tous les trois chiffres
+	Affiche le signe du nombre
^^^^	Ecriture scientifique (format exponentiel)
-	Placé après la chaine. Affiche – après les nombres négatifs.
$$	Affiche $ à la gauche du nombre
**	Remplace les espace de tête pas *
**$	Applique ** et $$

FORMATAGE D’UNE EXPRESSION CHAÎNE DE CARACTÈRES
Caractères	Effet
&	affiche toute la chaîne
!	Affiche seulement le premier caractère de la chaîne
\ \	Affiche les n + 2 premiers caractères de la chaîne, où n est le nombre d’espaces entre les deux barres.
_	Affiche le caractère suivant

Concrétement, qu’est ce que ça donne? Observez l’exemple suivant :



a = 3.14159265458#

a$ = « Hello, It’s me ! »

CLS

PRINT USING « #.## »; a

PRINT USING « ############^^^^ »; a

PRINT USING « +##.## »; a

PRINT USING « & »; a$

PRINT USING « ! »; a$

PRINT USING « \\ »; a$

PRINT USING « \   \ »; a$

LEN, LEFT$, RIGHT$, MID$

LEN, LEFT$, RIGHT$ et MID$ permettent de traiter facilement les chaînes de caractères.

LEN renvoi le nombre de caractère que contient une châine :



CLS

INPUT « Entrez du texte, n’importe quoi : « , Texte$

PRINT « Vous avez écrit « ; LEN(Texte$);  » caractères. »

LEFT$ renvoi n caractères de la chaîne en partant de la gauche :



CLS

INPUT « Entrez du texte, n’importe quoi : « , Texte$

INPUT « Combien de caractère de la gauche voulez-vous « ; C

PRINT LEFT$(Texte$, C)

RIGHT$ renvoi n caractères de la chaîne en partant de la droite :



CLS

INPUT « Entrez du texte, n’importe quoi : « , Texte$

INPUT « Combien de caractère de la droite voulez-vous « ; C

PRINT RIGHT$(Texte$, C)

MID$ renvoi n caractères à un endroit spécifié de la chaîne :



CLS

INPUT « Entrez du texte, n’importe quoi : « , Texte$

FOR i = 1 TO LEN(Texte$)

  PRINT « Caractère « ; i;  » : « ; MID$(Texte$,i ,1)

NEXT i

La table de caractères ASCII

La table de caractères ASCII est une table qui regroupe 256 caractères spéciaux, numérotés de
0 à 255. Cette table est accéssible à tout moment par le biais de l’aide en ligne de QBasic:
Appuyez sur Shift + F1, double cliquez sur ‘Table des matières‘, puis sur ‘Codes de caractères
ASCII‘ dans le cadre Référence.

Pour afficher ces caractères, on peut procéder de plusieurs façons:

De cette page d’aide, on peut copier le caractère désiré dans le presse papier grâce au
menu ‘Edition’, puis le coller entre guillemets dans une instruction PRINT.

On peut afficher la plupart (je dis bien la plupart) de ces caractères directement en
maintenant la touche ‘ALT’ enfoncée, puis en tapant le code correspondant au caractère.

On peut utiliser l’instruction CHR$

Pour utiliser l’instruction CHR$, il suffit d’écrire le code du caractère entre parenthèses
à la suite de CHR$. Le code suivant affiche tous les caractères de la table l’un à la suite de
l’autre:



CLS

FOR i = 0 TO 255

  PRINT CHR$(i);

NEXT i

Au contraire, pour retrouver le code d’un caractère, il faut utiliser l’instruction ASC.
La programme suivant retourne le code du caractère écrit. Remarquer l’utilisation de LEFT$ :



INPUT « Entrez un caractère (seul le premier est pris en compte!) : « , Char$

Char$ = LEFT$(Char$, 1)

PRINT ASC(Char$)’ Utilisation de ASC

Espaces et tabulations

Pour afficher des espaces, le plus simple serait d’utiliser l’instruction PRINT ainsi :
PRINT » « .

Ca marche, met admettons que le nombre d’espace varie a un moment du programme pour une raison
ou pour une autre? C’est pourquoi il existe l’instruction SPACE$ qui permet d’afficher un nombre n
d’espaces. Et ce nombre n peut varier. Le programme suivant écrit ‘Robert‘ puis ‘Dupont‘ 5
espaces plus loin :



PRINT « Robert »; SPACE$(5); « Dupont »

Dans ce cas là, on aurait pu utiliser l’instruction SPC qui a le même effet.
PRINT « Robert »; SPC(5); « Dupont » est équivalent.
Mais SPC n’est utilisable que dans une instruction PRINT. Autrement,
une erreur est provoquée. Par exemple :



Chaine$ = SPC(17)’ ATTENTION! Ce code est faut et provoque une erreur!

On lui préferera donc SPACE$.

Pour les tabulations, ont utilise l’instruction TAB, tout simplement, suivi du numéro
de la colonne. Le programme suivant illustre les possibilités de mise en page offertent par TAB :



CLS

PRINT TAB(25); « Au grand Bazar »

PRINT

PRINT « Article »; TAB(40); « PRIX »

PRINT STRING$(80, « - »)      ‘ Nous détailleront l’instruction

PRINT « Ducati 916″; TAB(40); « 120 000 francs » ‘ STRING$ ci après

PRINT « Melon »; TAB(40); « 10 francs la pièce »

PRINT « L’Equipe »; TAB(40); « 4,90 francs »

PRINT « PlayStation »; TAB(40); « 790 francs. »

PRINT « Super »; TAB(40); « 8,76 francs le litre   »

PRINT STRING$(80, « - »)

Grâce aux tabulations, on peut créer des colonnes régulières.

L’instruction STRING$

L’instruction STRING$ permet de répeter un certain nombre de fois un caractère.
Avouez que dans l’exemple ci-dessus, il auraît tout de même fallut écrire précisément 80 fois
le caractère ‘-‘.

LTRIM$ et RTRIM$

Nous avons appris a rajouter des espaces. Ce serait bête de ne pas savoir les enlever, non ?
Les instructions LTRIM$ et RTRIM$ vont y remédier.

LTRIM$ (avec un L comme LEFT) supprime les espaces de gauche.

RTRIM$ (avec un R comme RIGHT) supprime les espaces de droite.

Exemple:



Chaine$ = SPACE$(5) + « Il y a 5 espaces de chaque cotés » + SPACE$(5)

PRINT « Au départ : »

PRINT Chaine$

Chaine$ = RTRIM$(Chaine$)

PRINT « Après RTRIM$ : »

PRINT Chaine$

Chaine$ = LTRIM$(Chaine$)

PRINT « Après LTRIM$ : »

PRINT Chaine$

La casse…

On appele casse la façon dont est écrite un texte, selon qu’il soit en MAJUSCULES (ou CAPITAL,
je ne vois pas la différence) ou en minuscules. On utilise alors LCASE$
ou UCASE$ suivant l’effet recherché.

LCASE$ (avec un L comme LOW) transforme la chaine en minuscules.

UCASE$ (avec un U comme UP) transforme la chaine en majuscule.

Exemple:



Chaine$ = « ceci EST une CHAINE où LA cAsSe EsT DIffErrEnTTe »

PRINT « Avant transformations : »

PRINT Chaine$

PRINT « Avec UCASE$ : »

PRINT UCASE$(Chaine$)

PRINT « Avec LCASE$ : »

PRINT LCASE$(Chaine$)

Remarquez que le caractère accentué (ici ù) n’a pas changé.

Categories: QBasic Tags:

QBasic – Le son

25/03/2002 cybwarrior Aucun commentaire

This entry is part 15 of 30 in the series QBasic - Tutoriel

Faire un BIP
Emettre un son
Jouer de la Musique

Le QBasic posséde de multiples fonctions qui lui permettent d’emmettre des sons via le haut
parleur interne de votre PC. Pour la carte son, il faut s’y prendre autrement et en connaître
un petit peu plus …

Faire un BIP

Pour faire un BIP, il existe deux solutions:

Utiliser l’instruction PRINT avec le code ASCII 7:
```
PRINT CHR$(7)’ Cette ligne emet un BIP
```

Utiliser l’instruction BEEP, tout simplement:
```
BEEP’ Cette ligne emet un BIP
```

Emettre un son

Pour faire autre chose qu’un simple BIP, on peut utiliser l’instruction SOUND. En
théorie, cette instruction permet d’emettre 32730 sons (1 par Hertz) mais on en est loin.

Pour l’utiliser, il faut préciser deux arguments:

La fréquence en Hertz. Cette valeur peut varier de 37 à 32767.

La durée en tops d’horloge. Sachez qu’il y a 18.2 tops par seconde. La durée
peut varier de 0 à 65535, c’est à dire de 0 à 1 heure.

Paraît-il que le LA du diapason ce situe à 440 Hz. À titre indicatif, voici un petit tableau
que j’ai pompé dans INITIATION FACILE AU QBASIC – HENRI LILEN – P.S.I:

NOTE	Octaves
NOTE	1	2	3	4
Do	131	262	523	1047
Ré	147	294	587	1175
Mi	165	330	659	1319
Fa	176	349	698	1397
Sol	196	392	784	1568
La	220	440	880	1720
Si	247	494	988	1976

Vous aurez remarquez que, pour une note, il suffit de multiplier par 2 (ou diviser, c’est selon)
pour passer d’une octave à l’autre. Par exemple, pour jouer le fameux LA du diapason pendant,
disons… 5 secondes, on peut écrire ceci :



SOUND 440, 18.2 * 5′ LA du diapason : 440 Hz; 5 secondes : 18.2 * 5

Jouer de la Musique

Pour faire de la musique, on peut très bien utiliser SOUND en spécifiant les fréquences de
chaques notes, de chaque durée.

Ou alors, on peut utiliser l’instruction PLAY qui permet de jouer de la musique très
facilement.

PLAY s’utilise facilement. Il n’y a qu’un seul argument à lui fournir: une chaine de caractère
contenant la musique à jouer.

Cette chaine de caractères est constituée selon les rêgles suivantes :

On utilise les notes américaine (ou anglaise, je sais pas…), c’est à dire qu’il n’y
a pas de Do, Ré, Mi, Fa, Sol, La, Si, mais plutôt des C, D, E, F, G, A, B (Le Do,
c’est C; le Si, c’est B). Par exemple, pour jouer la gamme :

PLAY « CDEFGAB »

On utilise O (lisez O, comme le OOOOO de ZorOOOOOOO) pour changer d’octave. Il existe 7
octaves, numérotées de 0 à 6. Exemple :

PLAY « O0CDEFGABO6CDEFGAB »

On peut également passer à l’octave directement inférieur ou supérieur avec < ou
>. Exemple :

PLAY « CDEFGAB>CDEFGAB »

Pour jouer une note précise, on écrit N, suivit du numéro d’une des 85 notes des 7
ocataves confondues, sachant que l’on part de 0, et que justement, 0 est une pause. Exemple :

PLAY « N27″

Pour fixer la durée d’une note, on utilise L, suivit d’un nombre de 1 à 64. L1 est
une ronde, L2 est une demi-ronde… Exemple :

PLAY « L1N27″

Pour jouer une note à sa pleine durée, faite la précéder de ML. Pour la jouer à
7/8 de sa durée, faite la précéder de MN. Enfin, pour la jouer au 3/4, faite la
précéder de MS. Exemple :

PLAY « MLN27P1MNN27P1MSN27″

Le P utilisé dans l’exemple ci-dessus permet de marquer une pose de n noires
(de 1 à 64).

Pour fixer le tempo, on utilise T, suivi du nombre de noires par minute.

Normalement, la musique est joué au premier plan, c’est à dire que l’execution du
programme est stoppée jusqu’à ce que la musique soit entièrement jouée. Pour la
jouer en arrière plan, il suffit de le préciser avec MB. Ensuite, pour repasser
au premier plan, on utilise MF

Pour les dièses, on utilise # ou +

Pour le bémol, c’est -

Categories: QBasic Tags:

QBasic – Dessiner

25/03/2002 cybwarrior 3 commentaires

This entry is part 16 of 30 in the series QBasic - Tutoriel

L’instruction SCREEN
L’instruction WIDTH
Les couleurs
Les instructions PSET et PRESET
Lignes et rectangles (instruction LINE)
Tracer un cercle (CIRCLE)
DRAW
Le remplissage

Pour l’instant, nous avons utilisé exclusivement le mode texte. Ce mode est très limité est
ne permet pas d’exploiter à 100% les capacités graphiques offertes par QBasic. En QBasic, il
existe 12 mode d’écran (0 à 13, sauf 5 et 6).

L’instruction SCREEN

L’instruction SCREEN permet de passer d’un mode d’écran à un autre. Le mode d’écran
par défaut est le 0, c’est à dire le mode texte. Voici les differents mode possibles :

MODES D’ECRAN
Mode d’écran	Résolution (en pixels)	Couleurs	Texte	Adaptateurs graphiques
0	Mode texte uniquement	16	40 x 25, 40 x 43, 40 x 50, 80 x 25, 80 x 43, ou 80 x 50	MDPA, CGA, Hercules, Olivetti, EGA, VGA ou MCGA
1	320 x 200	4	40 x 25	CGA, EGA, VGA ou MCGA
2	640 x 200	2	80 x 25	CGA, EGA, VGA ou MCGA
3	720 x 348	1	80 x 25	Hercules, Olivetti ou AT&T
4	640 x 400	1	80 x 25	Hercules, Olivetti ou AT&T
7	320 x 200	16	40 x 25	EGA ou VGA
8	640 x 200	16	80 x 25	EGA ou VGA
9	640 x 350	16	80 x 25, ou 80 x 43	EGA ou VGA
10	640 x 350	4	80 x 25, ou 80 x 43	Ecran monochrome
11	640 x 480	2	80 x 30, ou 80 x 60	VGA ou MCGA
12	640 x 480	16	80 x 30, ou 80 x 60	VGA
13	320 x 200	256	40 x 25	VGA ou MGCA

L’instruction WIDTH

Avant d’entrer de plein fouet dans le dessin, une dernière remarque concernant le texte. Vous
aurez remarquez que dans la colonne ‘Texte’ du tableau ci-dessus, il arrive qu’il y est plusieurs
possibilités de résolution pour le mode texte.

Par exemple, pour le mode 0 (le plus riche), si on avait voulu un écran de 80 colonnes et
de 50 lignes, on aurrait écrit:



SCREEN 0′ Passage au mode d’écran 0

WIDTH 80, 50′ 80 colonnes et 50 lignes

Les couleurs

Il existe 16 couleurs en QBasic (de 0 à 15).

COULEURS
Couleur	Numéro	Modes d’écran
Noir	0	0, 1, 2, 7, 8, 9, 11, 12, et 13
Bleu	1	0, 7, 8, 9, 12, et 13
Vert	2	0, 7, 8, 9, 12, et 13
Cyan	3	0, 7, 8, 9, 12, et 13
Rouge	4	0, 7, 8, 9, 12, et 13
Violet	5	0, 7, 8, 9, 12, et 13
Marron	6	0, 7, 8, 9, 12, et 13
Blanc	7	0, 7, 8, 9, 12, et 13
Gris	8	0, 7, 8, 9, 12, et 13
Bleu clair	9	0, 7, 8, 9, 12, et 13
Vert clair	10	0, 7, 8, 9, 12, et 13
Cyan clair	11	0, 1, 7, 8, 9, 12, et 13
Rouge clair	12	0, 7, 8, 9, 12, et 13
Violet clair	13	0, 1, 7, 8, 9, 12, et 13
Jaune	14	0, 7, 8, 9, 12, et 13
Blanc brillant	15	0, 1, 2, 7, 8, 9, 11, 12, et 13

Pour changer la couleur, on utilise l’instruction COLOR. Suivant le mode d’écran
sélectionné, cette instruction peut avoir plusieurs arguments. Pour simplifier, voici un
tableau regroupant les différents cas:

L’INSTRUCTION COLOR
Mode d’écran	Syntaxe
0	COLOR Texte, Fond, Cadre
1	COLOR Fond
4, 12 et 13	COLOR Texte
7, 8, 9 et 10	COLOR Texte, Fond

Voici quelques exemples d’applications :

Mode 0 :



SCREEN 0

COLOR 0, 5, 4′ Texte Noir, Fond Violet, Cadre Rouge

PRINT « Ceci est un texte »

Mode 1 :



SCREEN 1

COLOR 1′ Fond Bleu

PRINT « Ceci est un texte »

Mode 4, 12 et 13 :



SCREEN 12

COLOR 2′ Texte Vert

PRINT « Ceci est un texte »

Mode 7, 8, 9 et 10 :



SCREEN 7

COLOR 8, 1′ Texte Gris, Fond Bleu

PRINT « Ceci est un texte »

Il est très facile de faire clignoter un texte. Il suffit pour cela d’ajouter
16 à la couleur séléctionnée.

Exemple :
SCREEN 0

CLS

FOR i = 0 to 15

  COLOR i

  PRINT « Couleur N° »; i;

  COLOR i + 16

  PRINT « Clignotement correspondant »

NEXT i

Les instructions PSET et PRESET

Ces instructions permettent de tracer un point sur l’écran. Leur syntaxe est très simple :



PSET (X, Y), [Couleur]

PRESET (X, Y), [Couleur]

Utilisées ainsi, ces deux instructions sont équivalentes. Mais si l’on ne spécifie pas le
dernier argument (Les arguments entre crochets [ et ] sont TOUJOURS faculatatifs)
qui indique la couleur a utiliser, PSET utilise la couleur de premier plan et PRESET
la couleur d’arrière plan. Ca peut être utile pour réaliser une animation sommaire. Et oui,
pour animer un graphisme, il faut d’abord effacer ce graphisme, puis le redéssiner ailleur.
Nous verrons un exemple plus tard. Pour l’instant, observez ce magnifique ciel étoilé
scintillent, grâce à l’utilisation de PSET, PRESET, RND, DO…LOOP :

SCREEN 1 ‘ 320 x 200 pixels
CLS

DO
PSET (RND * 320, RND * 200) ‘ On dessine un point au hasard
FOR i = 0 TO 100 ‘ On efface plusieurs point pour un ciel harmonieux
PRESET (RND * 320, RND * 200) ‘ On efface un point au hasard
NEXT i
LOOP

Pour quitter ce programme, tapez CTRL + PAUSE.

Lignes et rectangles (instruction LINE)

Pour tracer une ligne, on utilise l’instruction LINE. Voici sa syntaxe :



LINE (X1, Y1)-(X2, Y2)

Les coordonnées X1 et Y1 représente la première extrémité de la ligne. Les coordonnées X2 et Y2
corespondent quand à elles à la deuxième extrémité de la ligne. L’exemple suivant trace une
ligne oblique, au centre de l’écran :



SCREEN 12

CLS

LINE (50, 50)-(590, 430)’ Ligne

Pour déterminer la couleur de la ligne, on spécifie le numéro de la couleur. Par exemple, pour
une ligne rouge :



SCREEN 12

CLS

LINE (50, 50)-(590, 430), 4′ Ligne Rouge

Mais l’instruction LINE ne s’arrête pas là. Elle permet de tracer des rectangle en mentionnant
la lettre B (pour Box) comme argument. Le rectangle tracé aura alors pour premier coin X1 et Y1,
et comme coin opposé X2 et Y2. Autrement dit, il aura pour diagonale la ligne qui aurrait été
tracée sans B :



SCREEN 12

CLS

LINE (50, 50)-(590, 430), 4, B’ Rectangle Rouge

Maintenant, pour tracer un rectangle plein, on rajoute après le B, la lettre F (pour
Full. Ceci aura pour effet de remplir le rectangle avec la couleur choisie :



SCREEN 12

CLS

LINE (50, 50)-(590, 430), 4, BF’ Rectangle Rouge Rempli

Un dernier argument permet de spécifier l’aspect de la ligne. Il est codé sur 16 bits. Le
fonctionnement est assez complexe. Lisez si vous voulez.

Qui dit bit dit BINAIRE. Un entier de 16 bits, c’est en fait 16 chiffres, soit
0, soit 1, l’un à coté de l’autre. Par exemple 1010101010101010 est un nombre binaire.

Pour définit l’aspect de la ligne, QBasic regarde la position de chaque 1 ou 0 de gauche
à droite. Si c’est un 1, un point est dessiné. Si c’est un 0, il n’y en a aucun.



SCREEN 12

CLS

LINE (50, 50)-(590, 430), , , 3′ Ligne en pointillés (3 = 011 en binaire)

Tracer un cercle (CIRCLE)

Pour tracer un cercle sur l’écran, on utilise l’instruction CIRCLE dont la syntaxe est
la suivante :



CIRCLE (X, Y), Rayon

X et Y représentent le centre du cercle. Rayon est quand à lui le rayon du cercle. L’exemple
suivant trace un cercle de 50 pixels au centre de l’écran en mode d’écran 12 :



SCREEN 12

CLS

CIRCLE (320, 240), 50′ Un cercle

Comme pour une ligne, on peut changer la ligne en donnat le numéro de la couleur correspondante :



SCREEN 12

CLS

CIRCLE (320, 240), 50, 14′ Un cercle jaune

Et à partir d’ici, comme pour une ligne, il y a des tas d’arguments permettant de triturer ce
cercle.

On peut, par exemple, au lieu d’un cercle, tracer un arc. On spécifie pour celà l’angle de
départ de l’arc, puis la fin.

PETIT RAPEL DE MATHEMATIQUES
Les mesures d’angles doivent être exprimées en radians. 360° = 2 x PI rads Donc, pour convertir des degrès en radians, il faut effectuer l’opération suivante : Radians = 2 * PI / 360 * Degres En simplifiant l’équation : Radians = PI / 180 * Degres De plus, on adopte le sens trigonométrique (anti-horaire). Et comme dans un repère ortho-normé, on part de la partie X positif et Y positif.

Donc, si on suit scrupuleusement les rêgles énoncées, pour tracer le quart supérieur droit de
notre cercle, on écrit ceci :



CONST PI = 3.14159265458′ On définit la constante PI

SCREEN 12

CLS

CIRCLE (320, 240), 50, 14, 0, PI / 180 * 90′ Un quart de cercle jaune

Le dernier argument permet de dessiner une ellipse. Cet argument est en fait le rapport du
rayon Y sur le rayon X. Cette exemple transforme notre cercle de départ en élipse :



SCREEN 12

CLS

CIRCLE (320, 240), 50, 14, , , .5′ Une ellipse jaune

DRAW

Une dernière méthode graphique consiste à utilisé l’instruction DRAW. Cette instruction
remplace en quelque sortes ce qu’on appelait la tortue dans d’anciennes (mais alors anciennes!)
versions de langages dont certains ont malheuresement disparus aujourd’hui (malheuresement car
on pouvait tout de même bien s’amuser!).

Pour utiliser DRAW, on lui associe tout simplement une chaine de caractères où se trouve les
instructions à executer, à la manière de l’instruction PLAY pour le son.

D[n] Déplace le curseur vers le bas de n unités.

E[n] Déplace le curseur vers le haut et la droite de n unités.

F[n] Déplace le curseur vers le bas et la droite de n unités.

G[n] Déplace le curseur vers le bas et la gauche de n unités.

H[n] Déplace le curseur vers le haut et la gauche de n unités.

L[n] Déplace le curseur vers la gauche de n unités.

M+x,y Place le curseur sur le point x,y.

R[n] Déplace le curseur vers la droite de n unités.

U[n] Déplace le curseur vers le haut de n unités.

[B] Préfixe facultatif qui déplace le curseur sans tracé.

[N] Préfixe facultatif qui trace et retourne le curseur à sa position initiale.

An Effectue une rotation de n * 90 degrés (n peut être 0, 1, 2, ou 3).

Cn Définit la couleur de tracé (n est un attribut).

Pn1,n2 Définit les couleurs de remplissage et de bordure d’un objet (n1=couleur de remplissage, n2=couleur de bordure)

Sn Modifie l’échelle en définissant la longueur d’une unité de mouvement de
curseur. La valeur par défaut de n est 4, ce qui équivaut à un pixel.

TAn Rotation de n degrés (de -360 à 360).

L’exemple suivant trace un triangle réctangle :



SCREEN 1

CLS

‘ Pour être clair, on utilise la capacité qu’a QBasic à concaténer les chaines

‘ de caractères

Triangle$ = Triangle$ + « R15″           ‘ 15 unités à droites

Triangle$ = Triangle$ + « H15″           ‘ 15 unités en haut à gauche

Triangle$ = Triangle$ + « D15″           ‘ 15 untités vers le bas

DRAW Triangle$

Le remplissage

Ormis l’instruction LINE qui permet de remplir facilement un rectangle avec la couleur
choisie, on peut utiliser l’instruction PAINT pour remplir facilement une surface avec
une couleur, ce qui est très utile pour remplir un cercle créé avec l’instruction CIRCLE.

La syntaxe de cette instruction est :



PAINT (X, Y), Couleur

Il y a d’autres arguments, mais il ne sont guère utiles…

Pour créer une cible, on écrira :



SCREEN 12                        ‘ 640 x 480 pixels

CLS
Couleur = 14                     ‘ Définition de la couleur de remplissage

FOR i = 200 TO 0 STEP -50

  IF Couleur = 14 THEN Couleur = 4 ELSE Couleur = 14    ‘ Changement de la couleur

‘ (Jaune ou rouge)

  CIRCLE (320, 240), i, Couleur  ‘ On déssine le cercle…

  PAINT (320, 240), Couleur      ‘ …puis on le remplit

NEXT i

Categories: QBasic Tags:

QBasic – Sous-programmes, fonctions et procedures

25/03/2002 cybwarrior Aucun commentaire

This entry is part 17 of 30 in the series QBasic - Tutoriel

Sous-programmes
Les procédures
Les fonctions
Les variables

Sous-programmes

Imaginez que nous avions à executer le même code plusieurs fois de suites, à des endroits
différents du programme, de tel sorte que l’utilisation d’une boucle ou de conditions serait
impossible.

On pourrait tout simplement écrire autant de fois que nécéssaire le bout de code correspondant.
C’est vrai, on pourrait…

Mais on peut faire beaucoup plus malin : créer un sous-programme qui sera appelé lorqu’il le
faudra.

On utilise pour cela l’instruction GOSUB pour appelé le sous programme.

L’emploi de GOSUB est le même que GOTO. On spécifie le nom de l’étiquette où se trouve le
code à executer et le tour est joué!

Question sous programme, il faudra tout de même spécifier sa fin avec l’instruction RETURN.
Lorque le programme rencontrera cette instruction il reviendra au GOSUB qu’il la appelée. Mais
un exemple vaut mieux qu’un long discours :

CONST PI = 3.14159265458
CLS
PRINT « Ce programme utilise l’emploi de GOSUB et RETURN »
PRINT « pour calculer l’aire d’un cercle »
PRINT
INPUT « Entrez le rayon du cercle : « , Rayon
GOSUB CalculAire’ Appel du sous programme ‘CalculAire’
PRINT « L’aire de ce cercle est de « ; Aire
END

CalculAire:’ Etiquette ‘CalculAire’. C’est le sous-programme
Aire = PI * Rayon ^ 2
RETURN’ Fin du sous-programme, on retourne au GOSUB

À noter que comme pour GOTO, GOSUB peut aussi se transformer en ON GOSUB. Ainsi, on pourra
tester la valeur d’une variable et aller au sous-programme approprié.

Les procédures

Mais on peut encore mieux faire. Comment ? En créant une procédure. Par exemple, vous aurez
remarqué que pour écrire un texte à un endroit bien précis, il faut utiliser 2 instructions :

LOCATE, pour placer le curseur à l’endoit voulu

PRINT, pour écrire le texte

Si on doit écrire du texte un peu partout sur l’écran, écrire LOCATE et PRINT à chaque fois
deviendra vite enuyeux. On peut alors créer une SUB (une procédure, quoi). Vous avez
certainement déja rencontré ce terme en parcourant les menus de QBasic. Nous l’appellerons
Ecrire.

Pour créer la procédure qui va nous épargner tant de labeur, on peut commencer de deux
façons :

Aller dans le menu ‘Edition’ et séléctionner ‘Nouvelle SUB’, puis écrire dans l’emplacement
‘Nom’, ‘Ecrire’.

Tout bêtement, ce placer à la fin (j’ai bien dit à la fin) du programme est écrire :
SUB Ecrire

Maintenant, on va devoir spécifier les arguments à utiliser. Qu’est ce qu’un argument ? C’est
par exemple les coordonnées X et Y de l’instruction PSET, le texte à afficher de l’instruction
PRINT, etc…

Ici, nos arguments seront :

La colonne

La ligne

Le texte

Pour cela, il faut se placer à la fin de la ligne SUB Ecrire et rajouter la
parenthèse suivante : (Colonne, Ligne, Texte$)

Ça doit donner ceci :



SUB Ecrire (Colonne, Ligne, Texte$)
END SUB

Maintenant, nous devons traiter ces arguments que le programme va nous passer quand la
procédure sera appelée.

Tout d’abord, nous devons déplacer le curseur à l’endroit spécifié :



SUB Ecrire (Colonne, Ligne, Texte$)

LOCATE Ligne, Colonne              ‘ On place le curseur à la ligne

   ‘ et à la colonne spécifiée

END SUB

Puis, nous devons écrire le texte :



SUB Ecrire (Colonne, Ligne, Texte$)

LOCATE Ligne, Colonne

PRINT Texte$                       ‘ On écrit le texte passé en argument

END SUB

Notre procédure est finie. Nous allons la tester. Il nous faut revenir dans le corps du
programme. Pour cela, allez dans le menu ‘Affichage’ et cliquez sur ‘SUBs’ ou appuyez sur
la touche F2 (raccourci clavier). Une fenêtre s’affiche, indiquant toutes les Procédures et
Fonctions du programme. Séléctionnez votre programme (normalement, ‘Sans_nom’).

Pour l’instant, aucune ligne de code ne doit normalement se trouver.

Dans la théorie, on devrai rajouter en début de programme la ligne suivante, pour dire à QBascic
qu’on utilise une procédure que l’on a crée :



DECLARE SUB Ecrire (Colonne, Ligne, Texte$)

Mais elle doit normalement s’écrire d’elle même lorque vous sauvegardez votre programme.

Pour tester notre procédure, nous allons écrire :



Ecrire 15, 10, « Bonjour ! »

Et comme par magie, Bonjour ! est écrit à la 15^ème colonne et à la 10
^ème ligne.

Les fonctions

Une fonction, c’est exactement la même chose qu’une procédure. À deux détails près cependant :

Une fonction renvoi une valeur, alors qu’une procédure, non.

On écrit plus SUB, mais FUNCTION. Ca peut paraitre évident, mais dans certains
langages, la distinction ne se fait pas.

Par exemple, lorsque vous utilisez l’instruction CSRLIN pour savoir sur quelle ligne le curseur
se trouve, CSRLIN prend la valeur de la ligne.

Reprenons notre exemple de départ, qui calcul l’aire d’un cercle. Nous allons améliorer ce
programme en créant une fontion que l’on appelera Aire.

Comme pour une procédure, vous pouvez créer une fonction en passant soit par le menu ‘Edition’
‘Nouvelle FUNCTION’ et en écrivant dans ‘Nom’ : ‘Aire’, soit en ce plaçant à la fin du programme
et en écrivant FUNCTION Aire.

Et là, comme pour une procédure, il nous faut spécifier les arguments. Ici, il n’y aura que le
rayon, donc :



FUNCTION Aire (Rayon)
END FUNCTION

Ensuite, on écrit le code à executer, soit :



FUNCTION Aire (Rayon)

Aire = 3.14159265458 * Rayon ^ 2

END FUNCTION

À ce stade là, quelques explications sont peut être nécessaires.

Déjà, nous n’avons pas défini de constante pour PI, mais avons utilisé la valeur numérique
directement

Ensuite, on a affecté à Aire, qui est le nom de la fonction, le résultat.

Attention ! Ici, on a affecté directement le résultat à Aire. Mais gardez à
l’esprit qu’une fonction ne se comporte pas comme une variable.

Du fait, on ne peut pas écrire des choses du style :



FUNCTION Aire (Rayon)

Aire = 3.14159265458

Aire = Aire * Rayon

Aire = Aire * Rayon

END FUNCTION

La logique est bonne, mais ceci aurrai pour effet d’appeler la fonction Aire, qui à son tour appelera la fonction Aire, etc…
Si on avait voulu suivre cette logique il aurrai falut écrire :



FUNCTION Aire (Rayon)

Resultat = 3.14159265458

Resultat = Resultat * Rayon

Resultat = Resultat * Rayon

Aire = Resultat

END FUNCTION

Maintenant que notre procédure est finie, nous allons l’utiliser. Pour cela, placer vous dans
le corps principal du programme, et écrivez :



INPUT « Entrez le rayon du cercle : « , Rayon

PRINT « L’aire du cercle est « ; Aire(Rayon)’ Appel de la fonction.

‘ Notez les parenthèses

Les variables

Une variable qui est utilisé dans une procédure ou une fonction ne sera accessible que dans
celle ci.

C’est à dire que si par exemple, vous utilisez une variable x dans une procédure ou une fonction,
dans aucun cas vous ne pourrez avoir accès à elle, que ce soit d’une autre procédures ou fonction,
ou même du corps principal du programme. On dit alors que cette variable est une variable
locale
De même, cette variable x va perdre sa valeur entre chaque appel. Essayez le programme suivant (la procédure
est placée sur le même listing) :

MaProcedure
MaProcedure

SUB MaProcedure
PRINT « Valeur antécédente de X « ; X
INPUT « Entrez une valeur pour X « ; X
END SUB

Dans l’exemple ci-dessus, X perd sa valeur, vous pouvez le voir par vous même.
Pour remédier à ce problème, on peut utiliser le mot-clef STATIC, ce qui aura pour
effet de conserver la valeur de X entre chaque appel de la procédure

MaProcedure
MaProcedure

SUB MaProcedure
STATIC X’ On emploi le mot-clef STATIC pour conserver la valeur de X
PRINT « Valeur antécédente de X « ; X
INPUT « Entrez une valeur pour X « ; X
END SUB

Si vous voulez rendre accessible par toutes les procédures et fonctions une variable, il faut la rendre
publique. Avec l’exemple suvant, la variable est inaccessible:

MaVariable = 5
MaProcedure

SUB MaProcedure
PRINT « La valeur de la variable est « ; MaVariable
END SUB

Pour la rendre publique, on utilise les mots-clefs COMMON SHARED, qu’il faut utiliser
dans le corps du programme :

COMMON SHARED MaVariable
MaVariable = 5
MaProcedure

SUB MaProcedure
PRINT « La valeur de la variable est « ; MaVariable
END SUB

On dit alors que la variable ‘MaVariable‘ est une variable globale. Mais on peut aussi
créer des variables globales en utilisant juste SHARED suivit des variables, mais cette
fois ci, dans une procédure ou fonction.

Enfin, une procédure ou une fonction peut modifier la valeur d’une variable lorque celle-ci lui
est passée en argument. Exemple :

MaVariable = 15
PRINT « La variable vaut « ; MaVariable
Procedure MaVariable
PRINT « Après modification par la procédure : « ; MaVariable

SUB Procedure (Chose)
Chose = 30′ Modification de la variable passée en argument
END SUB

Categories: QBasic Tags:

QBasic – Les types de variables

25/03/2002 cybwarrior Aucun commentaire

This entry is part 18 of 30 in the series QBasic - Tutoriel

À quoi ça sert de spécifier un type ?
Et les chaines de caractères ?
Variables globales et locales (le retour)

Jusqu’à maintenant, nous n’avions pas compliqué cette histoire de variables. Mais ça va changer
.

Déjà, sachez qu’il existe 4 types de variables numériques :

TYPES DE VARIABLES NUMERIQUES
Type	Déscription	Suffixe	Fourchette	Exemples	Mémoire requise
INTEGER	Nombres entiers signés (16 bits)	%	-32 768 à 32 767	-12; 59; 32000	2 octets
LONG	Nombres entiers signés (32 bits)	&	-2 147 483 648 à 2 147 483 647	-2 100 000 001; 421; 666	4 octets
SINGLE	Nombre décimal (32 bits)	!	± -3×10³⁸ à ± 3×10³⁸	-23.4 55.444	4 octets
DOUBLE	Nombre décimal (64 bits)	#	± -10^-307 à ± 10³⁰⁸	-589 755; 3.14159265458; 4 000 000 000 000	8 octets

En QBasic, il n’en existe pas plus, contrairement à certains langages comme le Pascal, où ils se
multiplient.

Pour spécifier le type numérique qu’une variable numérique va recevoir, il existe deux
possibilités :

La déclaration IMPLICITE des variables : C’est la méthode que nous avons utilisé jusqu’à maintenant. C’est à dire que pour utiliser
une variable, il suffit d’écrire son nom lorque le moment de l’utiliser est arrivé.

Pour spécifier son type, on va rajouter à la fin de son nom le suffixe correspondant (voir
tableau ci-dessus), à la manière du $ pour une chaine de caractères. Exemples :
```
VariableInteger% = 5            ‘ % = INTEGER

VariableLong& = -96             ‘ & = LONG

VariableSingle! = -789.564      ‘ ! = SINGLE

VariableDouble# = 3.14159265458 ‘ # = DOUBLE
```

La déclaration EXPLICITE des variables : C’est la méthode que je recommande. Pourquoi? He bien
parce que dans (presque) tout les autres langages, la déclaration explicite est OBLIGATOIRE.
Donc, autant prendre de bonnes habitudes et s’y mettre tout de suite.

Pour déclarer une variable suivant cette méthode, il faut utiliser l’instruction DIM,
suivi du nom de la variable, puis du mot-clef AS, et enfin, du type de la variable.
Exemples :
```
DIM VariableInteger AS INTEGER   ‘ Variable du type INTEGER

DIM VariableLong AS LONG         ‘ Variable du type LONG

DIM VariableSingle AS SINGLE     ‘ Variable du type SINGLE

DIM VariableDouble AS DOUBLE     ‘ Variable du type DOUBLE
```

AVANT



DIM intVariableInteger AS INTEGER   ‘ Variable du type INTEGER

DIM lngVariableLong AS LONG         ‘ Variable du type LONG

DIM sngVariableSingle AS SINGLE     ‘ Variable du type SINGLE

DIM dblVariableDouble AS DOUBLE     ‘ Variable du type DOUBLE

À quoi ça sert de spécifier un type ?

Déjà, ça sert à gérer au mieux la memoire disponible. Aujourd’hui, ce n’est plus tellement un
problème, mais il y a quelques années pas si lointaines, s’en était un.

Ensuite, ça peut être très utile. Par exemple, si on assigne à une variable de type INTEGER, une
valeur décimale, la valeur va être arrondi.

De plus, cela facilite la compréhension du programme : si toutes les variables ont été déclarées
en début de programme et en début de chaque procédure éventuelle, on est sur de ne pas avoir
à utiliser des variables qui s’avererons inutiles.

Enfin, lorque nous allons créer nous même des types (et oui!), ce sera obligatoire.

Et les chaines de caractères ?

Les chaines de caractères ne possédent qu’un seul et unique type : le type STRING.
Jusqu’à maintenant nous les avons déclarées implicitement avec le suffixe $.

Pour la déclaration explicite, on fait pareil qu’avec les nombres :



DIM strNom AS STRING   ‘ strNom est une variable chaine de caractères

Ce qui est bien avec cette déclaration explicite des chaines de caractères, c’est qu’on
peut limiter le nombre de caractères que pourra contenir la variable. Par exemple, si on veut
limiter à 8 caractères cette variable ’strNom’ (par exemple, pour un nom de fichier), on
écrira :

DIM strNom AS STRING * 8 ‘ strNom est une variable de 8 caractères maxi

INPUT « Donnez un nom (seul les 8 premiers caractères sont prit en compte) « ; strNom
PRINT strNom

À ce moment là, la variable prendra autant d’octets qu’il y a de caractères (ici 8 octets).

Variables globales et locales (le retour)

Ce que je ne vous ai pas dit au chapitre précédent, c’est qu’on peut aussi rendre globale une
variable simplement avec DIM.

On emploie pour cela le mot-clef SHARED à la suite de DIM :



DIM SHARED MaVariable   ‘ Cette variable est globale

DIM AutreVariable       ‘ Celle-ci ne l’est pas

Categories: QBasic Tags:

QBasic – Les tableaux

25/03/2002 cybwarrior 2 commentaires

This entry is part 19 of 30 in the series QBasic - Tutoriel

Type de tableaux
Les tableaux dynamiques
LBOUND et UBOUND

Lorsque dans un programme, les données se multiplient, au lieu de créer 40000 variables, on
peut utiliser un tableaux qui aura pour effet de nous simplifier grandement la tache.

Pour créer un tableau, on utilise la même instruction que pour déclarer une variable :
l’instruction DIM.
Imaginons que l’on veuille étudier la taille des 10 éleves d’une petite classe. Nous allons
créer un tableaux à 1 dimensions (une ligne) :



DIM Taille(9)

Remarquez que l’on a écrit 9 et pas 10. Pourquoi ? Parce qu’on part de 0 et non de 1. Si on
avait voulut partir de 1, on aurrait écrit :



DIM Taille(1 TO 10)

Ou bien, si on avait voulu faire commencer TOUT les tableaux par 1 au lieu de 0, on aurait du
écrire :



OPTION BASE 1   ‘ Tout les tableaux commence par 1 et non 0

DIM Taille(10)

Le tableau aurait virtuellement (whoa!!) cette alure :

1	2	3	4	5	6	7	8	9	10

Pour stocker nos données dans ce tableau, il faut spécifer les coordonnées de la cellules dans
laquelle ont veut placer la donnée :



OPTION BASE 1   ‘ Tout les tableaux commence par 1 et non 0

DIM Taille(10)
Taille(3) = 1.7         ‘ 1.7 dans la cellule 3

Taille(7) = 1.65        ‘ 1.65 dans la cellule 7

Après cet exemple, le tableau sera (toujours virtuellement) :

1	2	3	4	5	6	7	8	9	10
		1.7				1.65

Nous allons maintenant réaliser notre petite étude statistique avec ce petit programme :



OPTION BASE 1     ‘ Les tableaux partent de 1

DIM Taille(10)    ‘ Création du tableau Taille
FOR i = 1 TO 10

  PRINT « Eleve N° »; i

  INPUT « Entrez sa taille : « , Taille(i)  ‘ On stocke la taille de chaque éleve

NEXT i
‘ *** Calcul de la taille Moyenne ***

FOR i = 1 TO 10

  Somme = Somme + Taille(i)

NEXT i

TailleMoyenne = Somme / 10
‘ *** Recherche du plus grand ***

FOR i = 1 TO 10

  IF Taille(i) > PlusGrand THEN PlusGrand = Taille(i)

NEXT i
‘ *** Recherche du plus petit ***

PlusPetit = PlusGrand

FOR i = 1 TO 10

  IF Taille(i) < PlusPetit THEN PlusPetit = Taille(i)

NEXT i
' *** Affichage des résultats ***

PRINT "La taille moyenne est "; TailleMoyenne

PRINT "Le plus petit est "; PlusPetit

PRINT "Le plus grand est "; PlusGrand

Mais les tableaux ne s’arrêtent pas là. On peut par exemple spécifier une 2^ème
dimension :



DIM MonTableau(5, 10)’ Tableau à 2 dimensions

Voici l’allure virtuelle de ce tableau :

	0	1	2	3	4	5
0
1
2
3
4
5
6
7
8
9
10

On peut d’ailleurs créer des tableaux qui sont en fait des cubes, en précisant une 3^ème
dimension :



DIM MonCube(5, 10, 25)  ‘ Tableau à 3 dimensions (Cube)

Ici, j’ai pas pu le représenter virtuellement (je tiens à ce mot

).

À ma connaissance, je crois qu’on peut déclarer jusqu’à 64 dimensions !!!!!

Mais là, il faut s’accrocher.

Type de tableaux

Comme pour une variable, un tableau peut être d’un type bien déterminé. Il faudra alors le
spécifier avec le mot-clef AS :



DIM Bottin(1000) AS STRING ‘ Un tableau de chaines de caractères

Les tableaux dynamiques

Lorsqu’on ne sait pas bien quelle taille doit avoir un tableau, on peut créer un tableau
dynamique.

Pour cela, il faut créer un tableau avec le bon nombre de dimensions, mais avec des limites
« bidons » :



DIM Bataille(0, 0) AS INTEGER ‘ Création d’un tableau à 2 dimensions

Puis, on le redimensionnera en conséquence grâce à l’instruction REDIM :



DIM Bataille(0, 0) AS INTEGER ‘ Création d’un tableau à 2 dimensions
REDIM Bataille(10, 10) AS INTEGER ‘ Redimensionnement du tableau

Malheuresement, si on avait stocké des données dans le tableau, celle-ci seront réinitialisés
lors du redimensionnement. Il faudra alors se débrouillé avec un deuxième tableau temporaire.

LBOUND et UBOUND

Lorque l’on ne connait pas les limites d’une dimension d’un tableau, on peut utiliser les
instructions LBOUND et UBOUND.

LBOUND permet d’obtenir la limite inférieur d’une dimension d’un tableau

UBOUND permet d’obtenir la limite supérieur d’une dimension d’un tableau

Pour les utiliser, il faut préciser le tableau concerné et la dimension à tester, tout en sachant
que la première dimension est 1 et non pas 0 :



DIM MonTableau(3 TO 27, 4 TO 56)
FOR i = 1 TO 2

  PRINT « La limite inférieur de la dimension « ; i;  » est « ; LBOUND(MonTableau, i)

  PRINT « La limite supérieur de la dimension « ; i;  » est « ; UBOUND(MonTableau, i)

NEXT i

Categories: QBasic Tags:

QBasic – Les types personalisés

25/03/2002 cybwarrior un commentaire

This entry is part 20 of 30 in the series QBasic - Tutoriel

Introduction sommaire à l’animation
Définition du type
Les types et les tableaux
Types dans types
Note sur les nombres aléatoires

QBasic est loin d’être un langage de programation orienté objet. Cependant, il permet quand
même à l’utilisateur de définir ses propres types de variable.

Créer un type peut être très utile dans des cas de programme très complexes (jeux ou autres)
et permet de n’avoir que quelques variables dans son code.

Pour expliquer ce qu’est un type, nous allons détailler un exemple de programme en utilisant.
But : faire rebondir une balle (ou plutôt un cercle) sur les 4 cotès de votre écran.

Introduction sommaire à l’animation

Avant d’attaquer les types, vous devez savoir que pour animer un objet (ici, ce sera notre
balle), il faut :

Effacer cet objet, c’est à dire le dessiner aux même coordonnées, mais avec la couleur
d’arrière plan.

Le redessiner à ces autres coordonnées.

Dans notre exemple, l’objet se limitant à un cercle, nous utiliserons cette technique. Mais
nous verrons plus tard une autre technique pour animer des dessins plus complexes.

Définition du type

Tout d’abord, nous devons définir les propriétés de notre balle :

Rayon : vu que l’instruction CIRCLE requiet un rayon et non un diamêtre, cette
propriété le définira.

X : les coordonnées X du centre du cercle sur l’écran.

Y : les coordonnées Y du centre du cercle sur l’écran.

CX : pour déplacer la balle, nous allons ajouter aux coordonnées X, ce
coefficient.

CY : de même, nous allons ajouter ce coefficient au coordonnées Y pour déplacer
le cercle.

Comme pour les boucles, on peut comparer un type à un Big-Mac : deux tranches de pain et le
reste au milieu. Le reste, ce sera nos propriétés que nous avons défini ci dessus :



TYPE TBalle         ‘ Le nom de notre type est TBalle

  Rayon AS INTEGER  ‘ Propriété Rayon, du type INTEGER

  X AS SINGLE       ‘ Propriété X, du type SINGLE

  Y AS SINGLE       ‘ Propriété Y, du type SINGLE

  CX AS SINGLE      ‘ Propriété CX, du type SINGLE

  CY AS SINGLE      ‘ Propriété CY, du type SINGLE

END TYPE            ‘ Fin du type

Pareil que pour les boucles, il est conseillé d’observer un retrait.

Cette fois notre type est créé. Il est désormais utilisable comme n’importe quel autre type
(INTEGER, SINGLE, LONG, DOUBLE, STRING).

Nous allons donc déclarer une variable ‘Balle‘ du type ‘TBalle‘ :