CyBWarrior

1. Sous-programmes
2. Les procédures
3. Les fonctions
4. 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

Series Navigation

«QBasic – DessinerQBasic – Les types de variables»