Pascal - Procédures

Procedures sont des sous-programmes qui, au lieu de renvoyer une seule valeur, permettent d'obtenir un groupe de résultats.

Définition d'une procédure

En Pascal, une procédure est définie à l'aide du proceduremot-clé. La forme générale d'une définition de procédure est la suivante -

procedure name(argument(s): type1, argument(s): type 2, ... );
   < local declarations >
begin
   < procedure body >
end;

Une procédure definition en Pascal se compose d'un header, local declarations et un bodyde la procédure. L'en-tête de la procédure se compose du mot-cléprocedureet un nom donné à la procédure. Voici toutes les parties d'une procédure -

• Arguments- Le ou les arguments établissent le lien entre le programme appelant et les identificateurs de procédure et sont également appelés paramètres formels. Les règles des arguments dans les procédures sont les mêmes que celles des fonctions.

• Local declarations - Les déclarations locales font référence aux déclarations d'étiquettes, de constantes, de variables, de fonctions et de procédures, qui ne s'appliquent qu'au corps de la procédure.

• Procedure Body- Le corps de la procédure contient une collection d'instructions qui définissent ce que fait la procédure. Il doit toujours être placé entre les mots réservés de début et de fin. C'est la partie d'une procédure où tous les calculs sont effectués.

Voici le code source d'une procédure appelée findMin () . Cette procédure prend 4 paramètres x, y, z et m et stocke le minimum parmi les trois premières variables dans la variable nommée m. La variable m est passée parreference (nous discuterons des arguments de passage par référence un peu plus tard) -

procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m := x
   else
      m := y;
   
   if z <m then
      m := z;
end; { end of procedure findMin }

Déclarations de procédure

Une procédure declarationindique au compilateur un nom de procédure et comment appeler la procédure. Le corps réel de la procédure peut être défini séparément.

Une déclaration de procédure a la syntaxe suivante -

procedure name(argument(s): type1, argument(s): type 2, ... );

Veuillez noter que le name of the procedure is not associated with any type. Pour la procédure définie ci-dessus findMin () , voici la déclaration -

procedure findMin(x, y, z: integer; var m: integer);

Appel d'une procédure

Lors de la création d'une procédure, vous donnez une définition de ce que la procédure doit faire. Pour utiliser la procédure, vous devrez appeler cette procédure pour exécuter la tâche définie. Lorsqu'un programme appelle une procédure, le contrôle du programme est transféré à la procédure appelée. Une procédure appelée exécute la tâche définie et lorsque sa dernière instruction de fin est atteinte, elle renvoie le contrôle au programme appelant.

Pour appeler une procédure, il vous suffit de transmettre les paramètres requis avec le nom de la procédure comme indiqué ci-dessous -

program exProcedure;
var
   a, b, c,  min: integer;
procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m:= x
   else
      m:= y;
   
   if z < m then
      m:= z;
end; { end of procedure findMin }  

begin
   writeln(' Enter three numbers: ');
   readln( a, b, c);
   findMin(a, b, c, min); (* Procedure call *)
   
   writeln(' Minimum: ', min);
end.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Enter three numbers:
89 45 67
Minimum: 45

Sous-programmes récursifs

Nous avons vu qu'un programme ou sous-programme peut appeler un autre sous-programme. Lorsqu'un sous-programme s'appelle lui-même, il est appelé appel récursif et le processus est appelé récursivité.

Pour illustrer le concept, calculons la factorielle d'un nombre. La factorielle d'un nombre n est définie comme -

n! = n*(n-1)!
   = n*(n-1)*(n-2)!
      ...
   = n*(n-1)*(n-2)*(n-3)... 1

Le programme suivant calcule la factorielle d'un nombre donné en s'appelant lui-même récursivement.

program exRecursion;
var
   num, f: integer;
function fact(x: integer): integer; (* calculates factorial of x - x! *)

begin
   if x=0 then
      fact := 1
   else
      fact := x * fact(x-1); (* recursive call *)
end; { end of function fact}

begin
   writeln(' Enter a number: ');
   readln(num);
   f := fact(num);
   
   writeln(' Factorial ', num, ' is: ' , f);
end.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Enter a number:
5
Factorial 5 is: 120

Voici un autre exemple, qui génère le Fibonacci Series pour un nombre donné en utilisant un recursive fonction -

program recursiveFibonacci;
var
   i: integer;
function fibonacci(n: integer): integer;

begin
   if n=1 then
      fibonacci := 0
   
   else if n=2 then
      fibonacci := 1
   
   else
      fibonacci := fibonacci(n-1) + fibonacci(n-2);
end; 

begin
   for i:= 1 to 10 do
   
   write(fibonacci (i), '  ');
end.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

0 1 1 2	3 5 8 13 21 34

Arguments d'un sous-programme

Si un sous-programme (function or procedure) consiste à utiliser des arguments, il doit déclarer des variables qui acceptent les valeurs des arguments. Ces variables sont appeléesformal parameters du sous-programme.

Les paramètres formels se comportent comme les autres variables locales à l'intérieur du sous-programme et sont créés à l'entrée dans le sous-programme et détruits à la sortie.

Lors de l'appel d'un sous-programme, les arguments peuvent être transmis au sous-programme de deux manières:

Sr. Non	Type d'appel et description
1	Appel par valeur Cette méthode copie la valeur réelle d'un argument dans le paramètre formel du sous-programme. Dans ce cas, les modifications apportées au paramètre à l'intérieur du sous-programme n'ont aucun effet sur l'argument.
2	Appel par référence Cette méthode copie l'adresse d'un argument dans le paramètre formel. À l'intérieur du sous-programme, l'adresse est utilisée pour accéder à l'argument réel utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affectent l'argument.

Par défaut, Pascal utilise call by valuepour passer des arguments. En général, cela signifie que le code dans un sous-programme ne peut pas modifier les arguments utilisés pour appeler le sous-programme. L'exemple de programme que nous avons utilisé dans le chapitre 'Pascal - Fonctions' a appelé la fonction nommée max () en utilisantcall by value.

Alors que l'exemple de programme fourni ici ( exProcedure ) appelle la procédure findMin () en utilisantcall by reference.