<< Retour au sommaire

 

Les procédures et la portée des variables

 

 

 

Le sommaire :

1.      Présentation de la procédure ;

2.      La procédure simple ;

3.      La procédure avec paramètres ;

4.      La procédure de type fonction ;

5.      Les variables globales.

 

Présentation de la procédure

 

Afin d’éviter la répétition de codes, nous avons la possibilité d’encapsuler une partie autonome du programme dans un module indépendant, la procédure.

Ainsi, le traitement que renferme la procédure peut être appelé à tout moment durant l’exécution du programme sans pour autant que ce traitement soit réécrit.

 

En résumé, on débute le programme par l’écriture des procédures, et chaque procédure est identifiable par son nom.

 

Le mot clé « Procedure » permet de débuter l’écriture de la procédure, et le mot clé « EndProcedure » boucle la procédure.

 

La syntaxe globale :

Procedure NomDeLaProcédure()

Traitement

EndProcédure

(Le début du programme ici)

 

La description :

Procedure est le mot clé qui permet de déclarer l’écriture d’une procédure.

 

NomDeLaProcédure est le nom de la procédure, c’est nous qui le choisissons, les règles d’écritures sont identiques à celles d’une variables, toutefois, il conviendra ici d’ouvrir et de fermer les parenthèses après le nom.

 

Traitement est le code PureBasic qui réalise des opérations.

 

EndProcedure est le mot clé qui termine l’écriture de la procédure.

 

Ensuite, vient le code du programme lui-même, c’est d’ailleurs lui qui prend la main lors de l’exécution du programme. Cette partie est dite le « programme principal ».

 

Comment exécuter une procédure ?

Eh bien, n’importe où dans le programme, il suffit d’écrire le nom de la procédure suivi des 2 parenthèses.

 

Important !

·        Il faut que la procédure soit écrite, donc déclarée, avant d’être utilisée, c’est logique, non ?

 


La procédure simple

 

Dans le programme que je vais vous présenter maintenant, le code débute par l’écriture d’une procédure, elle s’appelle « DireBonjour ».

Lors du démarrage du programme, la procédure est lue, puis mise en mémoire sans être exécutée, mais cependant, prêt à l’être !

L’exécution du programme débute donc à la fin des déclarations des procédures…

Ensuite, dès que le nom d’une procédure est spécifié, cette dernière est exécutée.

Cette ligne de commande est dite « Appel de procédure ».

 

Au fait, ce programme permet de choisir l’exécution de l’une des 2 procédures présentes, et ce, selon si le programmeur a déjà dit bonjour à l’utilisateur, vous devinez alors l’intérêt implacable de cette application que je pourrais vendre horriblement cher…

 

1.      OpenConsole ()

2.      Procedure DireBonjour ()

3.      ; écriture de la procédure DireBonjour

4.      PrintN ("Salut mec ! Comment vas-tu en ce moment ? ")

5.      EndProcedure

6.      Procedure DireEncore ()

7.      ; écriture de la procédure DireEncore

8.      PrintN ("Encore toit ! Vas-tu enfin me lâcher !")

9.      EndProcedure

10.  ; Début de l'exécution du programme ici

11.  Print ("Eh toi, c'est-on deja vu ? oui/non ")

12.  Reponse$ =Input ()

13.  If Reponse$="oui" ; Traitement de la réponse

14.  DireEncore () ; Exécution de la procédure DireEncore car on a déjà croisé l'utilisateur

15.  Else

16.  DireBonjour (); Il faut être poli et dire bonjour, c'est la première fois qu'on le croise

17.  EndIf

18.  ; Blocage de l'affichage dans la console de la procédure qui vient d'être exécutée

19.  Input ()

 

Télécharger le fichier exemple, Source23.pb >>

 


La procédure avec paramètres

 

Le problème, voyez-vous, c’est qu’une procédure ne peut malheureusement pas accéder aux variables qui sont employées dans le corps principal du programme.

Pourquoi ?

Eh bien parce qu’une variable a une portée limitée.

Une variable déclarée dans le programme principal est inconnue des procédures, et inversement.

C’est la raison pour laquelle elles sont dites « variables locales », et cette contrainte universelle de la programmation relève du domaine de « la portée des variables ».

 

En clair, une variable qui est crée dans une procédure, est initialisée à chaque exécution de la procédure, et meurt à la fin de l’ »exécution.

 

Pour résoudre ce problème, nous avons plusieurs possibilités, ici dans ce chapitre, nous allons étudier les variables de passage qui sont en fait des paramètres à la procédure.

Au moment de l’appel de la procédure, on place les données à envoyer à la procédure par le biais des parenthèses. Et si nous devons passer plusieurs données, donc plusieurs paramètres, on les sépare par une virgule.

La virgule est donc le séparateur des paramètres…

 

Les paramètres peuvent bien sûr être des données, des variables, des constantes ou même, pourquoi pas, des instructions qui retournent une valeur.

 

Au niveau de la déclaration des procédures impliquant un passage de paramètres, il faut déclarer des variables dans les parenthèses, juste après le nom de la procédure.

Ces variables de passage doivent être du même type, et dans le même ordre que celles passées en paramètres au moment de l’appel de la procédure.

 

La syntaxe :

Procedure NomDeLaProcédure (VarPassage1,VarPassage2)

Traitement

EndProcedure

; Le programme principal

Du code blablabla

; Exécution de la procédure

NomDeLaProcédure (Param1,Param2)

Encore du code blablabla

 

La description :

Au moment du démarrage du programme, la procédure intitulée « NomDeLaProcédure » est lue, puis, mise en mémoire vive sans être exécutée.

Le programme principal quant à lui est exécuté.

Soudain, tandis que personne ne s’y attendait, le système constate qu’il y a une ligne d’appel de procédure, et cette procédure, c’est justement la nôtre, celle qui est en mémoire !

Mais comme la procédure attend 2 paramètres, eh bien, 2 paramètres sont très logiquement passés entre parenthèses à la procédure appelée.

Puis, la procédure est enfin exécutée !

Avant de débuter son traitement, la procédure prend la donnée de Param1 et la transfère dans VarPassage1, et la donnée de Param2 dans VarPassage2.

Le traitement peut alors débuter, la procédure dispose des 2 données dans les variables locales VarPassage1 & VarPassage2.

Toutefois, si la procédure a besoin de retourner un résultat, eh bien, ce sera dans les 2 chapitres suivants…

 

Pour l’heure, consacrons notre énergie sur la compréhension des paramètres d’une procédure !

Pour illustrer ce sujet, voici un exemple dans lequel l’appel de la procédure « DireBonjour » passe un paramètre, il s’agit du prénom de l’utilisateur.

 

1.      OpenConsole ()

2.      Procedure DireBonjour (Prenom$)

3.      ; écriture de la procédure après récupération du prénom de l'utilisateur

4.      PrintN ("Salut "+Prenom$)

5.      EndProcedure

6.      ; Programme principal

7.      Print ("Quel est ton prenom ? ")

8.      Utilisateur$ =Input ()

9.      DireBonjour (Utilisateur$) ; Exécution de la procédure en passant en paramètre le prénom

10.  Print ("Pressez la touche Entree pour continuer...")

11.  Input ()

 

Télécharger le fichier exemple, Source24.pb >>

 


La procédure de type fonction

 

En tant normal, on considère que le type de procédure qui va vous êtes présenté dans ce chapitre est de type fonction.

En effet, la différence entre une procédure et une fonction, c’est que la fonction retourne un résultat.

Mais en PureBasic, on ne dira pas une fonction, c’est tout simplement une procédure qui retourne un résultat, voilà tout…

 

Vous connaissez d’ores et déjà des fonctions intégrées à PureBasic, par exemple Str.

Str reçoit un paramètre, il s’agit d’un entier et retourne un String.

Au niveau du code, pour récupérer le String, soit :

 

1.      Vous affectez le résultat à une variable :

MaChaine = Str (MonEntier)

 

2.      vous placez  la fonction en tant que paramètre dans une autre fonction qui attend justement un String en paramètre :

Print (Str (MonEntier))

 

Rassurez-vous, le mode d’emploi des procédures retournant un résultat est identique.

Seulement, il vous faut penser à insérer l’instruction qui permet de retourner le résultat depuis la procédure !

Il s’agit de :

ProcedureReturn Valeur

« Valeur » étant une donnée ou une variable.

 

Dans l’exemple qui suit, nous avons une procédure qui retourne le carré de l’entier passé en paramètre lors de l’appel de la procédure.

Dans ce premier exemple, il s’agit d’une procédure qui ne nécessite donc qu’un seul paramètre…

Cette procédure-fonction se nomme « Puissance2 » !

 

  1. Procedure Puissance2 (Nombre)
  2. ; Procédure qui calcule et retourne le carré du paramètre
  3. Resultat =Nombre*Nombre
  4. ProcedureReturn Resultat
  5. EndProcedure
  6. ; Le programme principal
  7. OpenConsole ()
  8. ; demande à l'utilisateur de saisir un nombre entier
  9. Print ("Saisissez l'entier qui sera eleve a la puissance 2 : ")
  10. Entier =Val(Input ()) ; Affectation de la réponse en réalisant une conversion en un entier
  11. ; Exécution de la procédure Puissance2
  12. PrintN (Str(Entier)+" puissance 2 egal "+Str(Puissance2(Entier)))
  13. Print ("Pressez la touche Entree pour continuer...")
  14. Input ()

 

Télécharger le fichier exemple, Source25.pb >>

 


Voici un second exemple, cette fois, la procédure nécessite 2 paramètres !

Le premier ? C’est une valeur entière ;

Le deuxième ? C’est une autre valeur entière, mais l’indice avec laquelle le premier paramètre doit être élevé à la puissance.

 

1.      Procedure Puissance (Valeur,Indice)

2.      ; Procédure qui calcule la puissance des paramètres

3.      For I = 1 To Indice

4.      If I=1

5.      ; Il s'agit de la première itération, initialisation de la variable produit

6.      Produit = valeur

7.      Else

8.      ; Il ne s'agit pas de la première itération, ajout du produit de la puissance courante

9.      Produit = produit * Valeur

10.  EndIf

11.  Next ; Fin de la boucle

12.  ProcedureReturn Produit ; Retourne le produit

13.  EndProcedure ; Fin de la procédure

14.  ; Début du programme principal

15.  OpenConsole ()

16.  Print ("Saisissez la valeur a elever a la puissance : ")

17.  Valeur =Val (Input ())

18.  Print ("Saisissez maintenant la puissance : ")

19.  Indice =Val (Input ())

20.  ; Exécution de la procédure

21.  PrintN (Str(Valeur)+" Puissance "+Str(Indice)+" donne "+Str(Puissance(Valeur,Indice)))

22.  Print ("Pressez la touche Entree pour continuer...")

23.  Input ()

 

Télécharger le fichier exemple, Source26.pb >>

 


Les variables globales

 

Parfois, on ne peut pas se contenter de conserver des données en les trimbalant à travers des paramètres de procédures !

En effet, il existe une variable bien plus puissante que la variable locale, c’est la variable globale.

La variable globale a la faculté de conserver son contenu tant que le programme est en cours d’exécution.

Alors pourquoi ne pas utiliser systématiquement ce type de variables ?

En fait, on n'encombre pas le programme de choses qui ne sont nécessaires qu’à un certain moment, c’est une règle fondamentale de base en programmation.

Pour déclarer une variable globale ?

Rien de plus simple…

Globale NomDeLaVariable

Il faut donc déclarer la variable par le biais du mot clé « globale » et placer les différentes déclarations dans l’entête du programme.

 

Voici un exemple qui permet à la procédure « Afficher » de retourner le résultat par une variable globale.

 

Remarque :

·        Vous allez constater qu’ici nous n’utilisons pas de paramètres d’appel de procédure car la donnée à traiter est contenue dans une variable globale, donc connue par la procédure.

 

  1. OpenConsole ()
  2. Global Nom$ ; Déclaration de la variable globale
  3. Procedure Afficher ()
  4. ; Procédure qui affiche le nom de l'utilisateur
  5. PrintN ("Ton nom est : "+Nom$)
  6. EndProcedure
  7. ; Programme principale
  8. Print ("Quel est ton nom mec ? ")
  9. Nom$ =Input ()
  10. Afficher () ; Exécution de la procédure
  11. Print ("Pressez la touche Entree pour continuer...")
  12. Input ()

 

Télécharger le fichier exemple, Source27.pb >>

 

Philippe BOULANGER