Cours de Turbo Pascal 7

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 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'un des mots réservés du Pascal. L'appel d'une procédure peut dépendre d'une structure de boucle, de condition, etc.

Une procédure peut utiliser des variables globales, définies par le programme principal, c'est-à-dire que ces variables sont valables pour tout le programme et accessibles 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 existence et ne peut donc pas les utiliser.

Syntaxe :

Program nom_de_programme;

Var variable : type;

Procedure nom_de_procedure;
Begin
  ...
  ...
End;

BEGIN
  ...
  nom_de_procedure;
  ...
END.

Exemple :

Program Exemple9a;

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 (fonction KeyPressed). Durant cette procédure, on additionne 10 à la valeur de a entrée par l'utilisateur, puis on effectue la racine carrée (sqrt) du nombre ainsi obtenu, et enfin, on cherche le sinus (sin) de ce dernier nombre.

Une procédure peut avoir ses propres variables locales.

Les variables n'existent 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 peuvent porter le nom de variables globales. Enfin, on peut utiliser, pour une variable locale dans une procédure, le nom d'une variable locale déjà utilisé dans une autre procédure.

Une procédure étant un sous-programme complet, elle peut contenir ses propres procédures et fonctions, qui ne sont accessibles que par leur procédure « mère », c'est-à-dire la procédure dans laquelle elles sont déclarées. Une sous-procédure ne peut appeler d'autres procédures ou fonctions que si ces dernières font partie du programme principal ou de la procédure qui la contient.

Syntaxe :

Procedure nom_de_procedure;
Var variable : type;

     Procedure nom_de_sous_procedure;
     Var variable : type;
     Begin
       ...
     End;
     
Begin
  ...
  ...
End;

On peut aussi créer des procédures paramétrées, c'est-à-dire qui reçoivent des variables comme 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.
La déclaration des paramètres 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. Lorsque le programme appelle la procédure et lui envoie des valeurs de type simple, celles-ci sont appelées paramètres réels, car les variables sont définies dans le programme principal et ne sont pas valables dans la procédure.

À noter qu'on peut passer en paramètre directement des valeurs (nombre, chaine de caractères…) aussi bien que des variables.

Syntaxe :

Program nom_de_programme;

Procedure nom_de_procedure ( noms_de_variables : types );
Begin
  ...
  ...
End;

BEGIN
  nom_de_procedure ( noms_d_autres_variables_ou_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 tableaux à l'aide du mot-clé Type (voir chapitre 20 sur les types simples et structurés).

Exemple :

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 dans 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'existence de la variable nombre; ainsi, pour qu'elle puisse l'utiliser, il faut la lui passer en paramètre !

Il est quelquefois nécessaire d'appeler une procédure paramétrée sans pour autant avoir de valeur à lui passer, mais on souhaiterait que ce soit elle qui nous renvoie 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 paramètre au sein de la procédure paramétrée, le mot-clé 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 absolument 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 absolument pas affecter en quoi que ce soit la valeur initiale 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, 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 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(Shaine) ;
  Affichage(Chaine) ;
END.

Ce programme Exemple9c illustre l'utilisation du mot-clé Var. En effet, le programme principal appelle pour commencer une procédure paramétrée Saisie et lui passe la valeur de la variable Chaine. 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 passe, c'est-à-dire ici d'y mettre le nom de l'utilisateur. Pour cela, on utilise le mot-clé Var. Lorsque cette procédure Saisie est terminée, la variable Chaine du programme principal a pris la valeur de la variable Nom de la procédure. Ensuite, on envoie à 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 pourront être 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; on pourra déclarer séparément (séparation par une virgule) les variables déclarées 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 affectent les variables globales, alors on devra placer devant chaque déclaration de types différents un Var.

Syntaxes :

Procedure nom_de_procedure (Var var1, var2 : type1 ; var3 : type1);
Begin
  ...
End;

Procedure nom_de_procedure (Var var1 : type1 ; Var var2 : type2);
Begin
  ...
End;