|
Les procédures et fonctions sont des sortes de sous-programmes écrits avant le programme principal mais
appelés depuis ce programme principal, d'une autre procédure ou même d'une autre fonction. Le nom d'une procédure ou d'une fonction (ou comme celui d'un tableau,
d'une variable ou d'une constante) de doit pas excéder 127 caractères et ne pas contenir d'accent. Ce nom doit, en
outre, être différent de celui d'une instruction en Pascal. L'appel d'une procédure peut dépendre d'une
structure de boucle, de condition, etc.
- Procédure simple
- Variables locales et sous-procédures
- Procédure paramétrée
- Syntaxe
Var
1. Procédure simple
Une procédure peut voir ses variables définies par le programme
principal, c'est-à-dire que ces variables sont valables pour tout le programme et accessible partout dans le programme
principal mais aussi dans les procédures et fonctions qui auront été déclarées après.
La déclaration des variables se fait alors avant
la déclaration de la procédure pour qu'elle puisse les utiliser. Car une procédure déclarée avant les variables ne
peut pas connaître leur existance et ne peut donc pas les utiliser.
Syntaxe :
Program nom de programme ;
Var variable : type ;
Procedure nom de procédure ;
Begin
...
commandes
...
End ;
nom de procédure ;
END.
Program ;
Uses crt ;
Var a, b, c : real ;
Procedure maths ;
Begin
a := a + 10 ;
b := sqrt(a) ;
c := sin(b) ;
End ;
BEGIN
Clrscr ;
Write('Entrez un nombre :') ;
Readln(a) ;
Repeat
maths ;
Writeln (c) ;
Until keypressed ;
END.
Ce programme exemple9a appelle une procédure appelée maths qui effectue des calculs successifs.
Cette procédure est appelée depuis une boucle qui ne se stoppe que lorsqu'une touche du clavier est pressée
(instruction keypressed). Durant cette procédure, on additionne 10 à la valeur de a entrée par
l'utilisateur, puis on effectue le carré (sqrt) du nombre ainsi obtenu, et enfin, on cherche le sinus
(sin) de ce dernier nombre.
2. Variables locales et sous-procédures
Une procédure peut avoir ses propres variables locales
qui seront réinitialisées à chaque appel. Ces variables n'existent alors que dans la procédure. Ainsi,
une procédure peut utiliser les variables globales du programme (déclarées en tout début) mais aussi ses propres variables
locales qui lui sont réservées. Une procédure ne peut pas appeler une variable locale appartenant à
une autre procédure. Les variables locales doivent porter des noms différents de celles globales si ces dernières
ont été déclarée avant la procédure. Enfin, on peut utiliser dans une procédure, un nom pour une variable locale
déjà utilisé pour une autre variable locale dans une autre procédure.
Une procédure, étant un sous-programme complet, peut contenir ses propres procédures et fonctions qui n'éxistent alors que lorsque
la procédure principale est en cours. Un sous-procédure ne peut appeler d'autres procédures ou fonctions que si ces dernières font parti du
programme principal ou de la procédure qui contient la sous-procédure.
Syntaxe :
Procedure nom de procédure ;
Var variable : type ;
Procedure nom de sous-procédure ;
Var variable : type ;
Begin
...
End ;
...
commandes
...
End ;
3. Procédure paramétrée
On peut aussi créer des procédures paramétrées (dont les variables n'existent que dans
la procédure). Ces procédures là ont l'intérêt de pouvoir, contrairement aux procédures simples, être déclarée avant les variables
globales du programme principal ; elles n'utiliseront que les variables passées en paramètres !
Le programme principal (ou une autre procédure qui aurait été déclarée après) affecte alors des valeurs de variables à
la procédure en passant des variables en paramètres.
Et ces valeurs s'incorporent dans les variables propres à la procédure (dont les identificateurs
peuvent ou non êtres identiques, ça n'a aucune espèce d'importance). La déclaration
des variables se fait alors en même temps que la déclaration de la procédure, ces variables
sont des paramètres formels car existant uniquement dans la procédure. Losque que
le programme appelle la procédure et lui envoie des valeurs de type simple (car celles de type
complexe ne sont pas acceptées, voir chapitre 20 sur les types), celles-ci
sont appellées paramètres réels car les variables sont définies dans le programme
principal et ne sont pas valables dans la procédure.
A noter qu'on peut passer en paramètre directement des valeurs (nombre, chaînes de caractères...) aussi bien que des variables.
Syntaxe :
Program nom de programme ;
Procedure nom de procédure( noms de variables : types ) ;
Begin
...
commandes
...
End ;
nom de procédure ( noms d'autres variables ou leurs valeurs ) ;
END.
Note : on peut passer en paramètre à une procédure des types simples et structurés.
Attention néanmoins à déclarer des types spécifiques de tableau à l'aide de la syntaxe Type
(voir Chapitre 20 sur les "Types simples et structurés") car le passage d'un tableau
en tant que type Array à une procédure est impossible.
Program exemple9b ;
Uses Crt ;
Procedure maths ( param : Real ) ;
Begin
WriteLn('Procédure de calcul. Veuillez patienter.') ;
param := Sin(Sqrt(param+10)) ;
WriteLn(param) ;
End ;
Var nombre : Real ;
BEGIN
ClrScr ;
Write('Entrez un nombre :') ;
ReadLn(nombre) ;
maths (nombre) ;
ReadLn ;
END.
Ce programme exemple9b appelle une procédure paramétrée appelée maths qui
effectue les mêmes calculs que le programme exemple9a. Mais ici, la variable est déclarée après la
procédure paramétrée. Donc, la procédure ne connaît pas l'existance de la variable nombre, ainsi,
pour qu'elle puisse l'utiliser, il faut le lui passer en paramètre !
4. Syntaxe Var (procédures et fonctions)
Il est quelquefois nécessaire d'appeller une procédure paramétrée sans pour autant avoir de
valeur à lui affecter mais on souhaiterait que ce soit elle qui nous renvoit des valeurs (exemple typique d'une procédure de saisie de valeurs par l'utilisateur) ou alors on désire que la procédure
puisse modifier la valeur de la variable passée en paramètre. Les syntaxes précédentes ne conviennent pas à ce cas spécial. Lors de la
déclaration de variable au sein de la procédure paramétrée, la syntaxe Var (placée devant l'identificateur de la variable )
permet de déclarer des paramètres formels dont la valeur à l'intérieur de la procédure ira remplacer la valeur,
dans le programme principal, de la variable passée en paramètre. Et lorsque Var n'est pas là, les paramètres formels doivent
impérativement avoir une valeur lors de l'appel de la procédure.
Pour expliquer autrement, si Var n'est pas là, la variable qu'on envoie en paramètre à la procédure
doit absoluement déjà avoir une valeur (valeur nulle acceptée). De plus, sans Var, la variable (à l'intérieur de
la procédure) qui contient la valeur de la variable passée en paramètre, même si elle change de valeur n'aura aucun effet sur la valeur
de la variable (du programme principal) passée en paramètre. C'est à dire que la variable de la procédure n'existe qu'à l'intérieur de
cette dernière et ne peut absoluement pas affecter en quoi que ce soit la valeur intiale qui fut envoyée à la procédure : cette valeur initiale reste
la même avant et après l'appel de la procédure. Car en effet, la variable de la procédure est dynamique : elle est créée lorsque la procédure
est appelée et elle est détruite lorsque la procédure est finie, et ce, sans retour d'information vers le programme principal. La procédure
paramétrée sans Var évolue sans aucune interaction avec le programme principal (même si elle est capable
d'appeler elle-même d'autres procédures et fonctions).
Par contre, si Var est là, la valeur de la variable globale passée en paramètre à la procédure va pouvoir
changer (elle pourra donc ne rien contenir à l'origine). Si au cours de la procédure la valeur est changée (lors d'un calcul,
d'une saisie de l'utilisateur...), alors la nouvelle valeur de la variable dans la procédure, une fois la procédure terminée,
ira se placer dans la variable globale (du programme principal) qui avait été passée en paramètre à la procédure.
Donc, si on veut passer une variable en paramètre dont la valeur dans le programme principal ne doit pas être modifiée
(même si elle change dans la procédure), on n'utilise pas le Var. Et dans le cas contraire, si on veut
de la valeur de la variable globale placée en paramètre change grâce à la procédure (saisie, calcul...), on colle un
Var.
Program Exemple9c ;
Uses Crt ;
Procedure Saisie ( var nom : String ) ;
Begin
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
End ;
Procedure Affichage ( info : String ) ;
Begin
WriteLn('Voici votre nom : ', info) ;
End ;
Var chaine : String ;
BEGIN
ClrScr ;
Saisie(chaine) ;
Affichage(chaine) ;
END.
Ce programme exemple9c illustre l'utilisation de la syntaxe Var.
En effet, le programme principal appelle pour commencer une procédure paramétrée Saisie et lui affecte la valeur
de la variable chaine (c'est-à-dire rien du tout puisque qu'avant on n'a rien mis dedans, même pas une chaine vide).
Au sein de la procédure paramétrée, cette variable porte un autre nom : nom, et
comme au début du programme cette variable n'a aucune valeur, on offre à la procédure la possibilité de modifier le
contenu de la variable qu'on lui envoit, c'est-à-dire ici d'y mettre le nom de l'utilisateur. Pour cela, on utilise la syntaxe
Var. Lorsque cette procédure Saisie est terminée, la variable chaine du programme
principal prend la valeur de la variable nom de la procédure. Ensuite, on envoit à la procédure Affichage
la valeur de la variable chaine (c'est-à-dire ce que contenait la variable nom, variable qui fut détruite lorsque la
procédure Saisie se termina). Comme cette dernière procédure n'a pas pour objet de modifier la valeur
de cette variable, on n'utilise pas le mot clé Var, ainsi, la valeur de la variable chaine ne
pourra pas être modifiée par la procédure. Par contre, même sans Var, la valeur de la variable
info pourrait varier au sein de la procédure si on le voulait mais cela n'aurait aucune influence sur la variable globale chaine.
Comme cette variable info n'est définie que dans la procédure, elle n'existera plus quand la procédure
sera terminée.
Il faut savoir qu'une procédure paramétrée peut accepter, si on le désire,
plusieurs variables d'un même type et aussi plusieurs variables de types différents. Ainsi, certaines pouront
êtres associées au Var, et d'autres pas. Si l'on déclare, dans une procédure paramétrée,
plusieurs variables de même type dont les valeurs de certaines devront remplacer celles initiales, mais d'autres non ; il faudra
déclarer séparément (séparation par une virgule ;) les variables déclarée avec Var
et les autres sans Var. Si on déclare plusieurs variables de types différents et qu'on veut que leurs
changements de valeur affecte les variables globales, alors on devra placer devant chaque déclaration de types différents
un Var.
Syntaxes :
Procedure identifiant(Var var1, var2 : type1 ; var3 : type1) ;
Begin
...
End ;
Procedure identifiant(Var var1 : type1 ; Var var2 : type2) ;
Begin
...
End ;
|
