Procédures

Une définition de procédure est une déclaration qui associe un identificateur à un bloc.
L’identificateur est le nom de la procédure. Une procédure est donc un bloc d’instructions
auquel on a donné un nom. L’invocation de ce nom provoque l’exécution du bloc qui, de fait,
se comporte comme une instruction complexe.

Les procédures servent à programmer de manière structurée. C’est l’approche qui consiste à
décomposer un problème en sous-problèmes, puis résoudre ces sous-problèmes et enfin
combiner les solutions des sous-problèmes pour obtenir la solution du problème de départ.

La définition d’une procédure correspond à la déclaration

L’utilisation d’une procédure correspond à l’appel.

Déclaration de procédure
Une déclaration de procédure comporte une en-tête et un corps.

L’en-tête comporte
 le mot clé Procédure
 le nom de la procédure
 la liste des paramètres formels (entre parenthèses), avec pour chaque paramètre son
nom, son type et son mode d’utilisation au moment de l’appel. Les paramètres formels
qui apparaissent dans l’en-tête sont des variables fictives qui sont précisées au moment
de l’appel
o un paramètre passé par valeur : à l’appel, la variable envoie sa valeur mais
n'est pas impliquée dans l’exécution
o un paramètre résultat  : après l’appel il récupère la valeur calculée ;
o un paramètre variable : il participe au calcul.
Une bonne pratique consiste à accompagner toute procédure d’une précondition et d’une
postcondition. Une procédure est alors vue comme un contrat :
1. La précondition fixe les obligations de l’utilisateur
2. La postcondition fixe les obligations du concepteur de la procédure.

Exemples :
1. Calcul du maximum de deux nombres A et B et stockage du résultat dans C :
Procédure Maximum (valeur A, B ; résultat C)
2. Échange de deux nombres A et B
Procédure Échange (variable A, B)

Le corps de la procédure comprend :

 la déclaration des variables locales qui ne durent que le temps de son exécution;
 la définition des fonctions et procédures propres à cette procédure, le cas échéant;
 la séquence des instructions à exécuter.
Il convient de remarquer que le corps de la procédure peut impliquer des variables globales.

Lorsque le corps de la procédure apparaît dans une instruction du programme englobant la

déclaration de procédure, on dit qu’il y a appel. Cet appel provoque l’exécution du bloc. Si la
déclaration de procédure comportait des paramètres formels, alors au moment de l’appel
doivent être passés à la procédure en respectant l’ordre adopté lors de la déclaration et le type
de passage précisé dans l’en-tête.

Calcul du maximum de deux nombres A et B et stockage du résultat dans C :

 Procedure Maximum (valeur A, B ; résultat C)
Begin If A>B than C := A else C := B end.

Echange de deux nombres A et B

Procédure Echange (variable A, B)
Begin Var C :
C := A ; A := B ; B := C
End.

Pour ce qui est des variables globales on peut les lier :

- soit à l’environnement de déclaration (liaison statique)
- soit à l’environnement de l’appel (liaison dynamique)

Exemple :

Program TOTO ;
Begin
Const x = 1 ;
Procedure P (Valeur y : integer) :
Begin
write (x+y)
End ;
Procedure Q ;
Var x : integer ;
Begin
X := 2 ;
P(3)
End ;

En liaison statique, P lie à l’appel, la variable globale x à celle qui est connue dans
l’environnement de déclaration, ci-dessous :
Program TOTO ;
Begin
Const x = 1 ;
Procedure P (Valeur y : integer) :
Begin
write (x+y)
End ;

c’est-à-d ‘’const x = 1’’. A l’appel P (y) donne alors ‘’write (1+y)’’ et le résultat est 4 puisque
y=3

En liaison dynamique, P lie à l’appel, la variable globale x à celle qui est connue dans
l’environnement de l’appel.
Var x : integer ;
Begin
x := 2 ;
P(3)
End ;

P (y) donne alors ‘’write (é+y)’’ et le résultat est 5 puisque y = 3.

Passage des paramètres.
Au moment de l’appel, le paramètre effectif est évalué jusqu’à un niveau fixé par la
déclaration ainsi qu’il suit :
Passage par valeur.
1. Le paramètre effectif est évalué jusqu’à obtention d’une valeur
2. Une variable locale à la procédure est créée et la valeur obtenue à l’évaluation ci-
dessus est utilisée pour initialiser cette variable.
3. Cette variable locale prend la place du paramètre formel lors de l’exécution du bloc.

Une paramètre passé par valeur équivaut donc à une variable locale initialisée au moment de
l’appel. Le paramètre effectif communique sa valeur au bloc lors de l’appel mais ne participe
pas aux calculs. C’est une communication à sens unique entre le paramètre effectif et la
procédure. L’appel n’a donc aucun effet sur le paramètre effectif.

Exercices :
1) Exécuter le programme ci-dessous
Program TOTO
Procedure P (valeur a : integer)
Begin a := 1 ; write (a) End ;
Var x : integer ;
Begin
x := 2 ; P(x) ; write (x) 
End.
Solution
C’est équivalent à
Program TOTO
Procedure P
Var a_loc : integer ;
Begin aa := 1 ; write (aa) End ;
Var x : integer ;
Begin
x := 2 ; (a_loc := 2 ; a_loc := 1 ; write (a_loc) ) ; write (x) 
End.
Les valeurs écrites sont d’abord 1 puis 2.

Passage par référence.

1. Le paramètre effectif est évalué jusqu’à obtention d’une variable
2. Cette variable prend la place du paramètre formel lors de l’exécution du bloc.

Tout se passe donc comme si le paramètre effectif passait son adresse à la procédure. C’est le
sens du mot ‘’référence’’.

1) Exécuter le programme ci-dessous

Program TOTO
Procedure P (Var a : integer)
Begin a := 1 ; write (a) End ;
Var x : integer ;
Begin
x := 2 ; P(x) ; write (x) 
End.

Solution
C’est équivalent à
Program TOTO
Procedure P (Var a : integer) ;
Begin a := 1 ; write (a) End ;
Var x : integer ;
Begin
x := 2 ; (x := 1 ; write (x) ) ; write (x) 
End.
Les valeurs écrites sont d’abord 1 puis 1.

Passage par nom

A l’appel, le paramètre effectif est évalué jusqu’à obtention d’un nom.

Passage par texte

A l’appel, le paramètre effectif est passé tel quel à la procédure sans aucune évaluation.

Exemple
Program TOTO
Procedure Echange (… x, y : integer) ;
Var aux : integer ;
Begin aux := y ; y := x ; x := aux End ;
Var i : integer ;
Var V : array 1 : 2 of integer ;
Begin i := 1 ; V1 := 2 ; V2 := 0 ;
Echange (if Vi = i+1 then Vi else i, i)
End.

Passage par nom.

La paramètre effectif est évalué jusqu’à obtention d’un nom.
Comme i = 1 et V1 = 2, l’évaluation de (if Vi = i+1 then Vi else i, i) donne
(if V1 = 1+1 then Vi else i) donne Vi.
A l’appel il faut donc exécuter Echange (Vi , i)
D’où :
aux := i ; i := Vi ; Vi := aux, c-à-d
aux := 1 ; i := V1 donc i = 2, et Vi := aux (donc V2 = 1). A noter que V1 = 2.
Ce mode de passage done pour résultat
i = 2, V1 = 2 et V2 = 1 ;

Passage par texte.

La paramètre effectif est passé tel quel.
Comme i = 1 et V1 = 2, cela donne :
aux := i ;
i := (if Vi = i+1 then Vi else i, i) ;
(if Vi = i+1 then Vi else i, i):= aux ;
Soit
aux := 1 ;
i := V1 donc i = 2,
(if V2 = 2+1 then V2 else i) := aux, c-à-d i:= aux (ce qui donne 1 à la variable i)
Ce mode de passage done pour résultat
i = 1, V1 = 2 et V2 = 0 ;