CHAPITRE 5 : Les Actions paramétrées (Procédures et Fonctions)

I. Introduction :

L’objet de ce chapitre est de présenter un moyen très puissant pour structurer un algorithme. Il
s’agit des procédures et fonctions, appelées aussi actions paramétrées.
En effet un problème peut être décomposé en plusieurs sous problèmes et chaque sous
problème donne lieu à un sous algorithme. L’algorithme de résolution de Problème initial est
une suite ordonnée des sous algorithmes de résolution de tous les sous Problèmes (Les
différents algorithmes sont relativement indépendants).
Définition d'une action paramétrée : Une action paramétrée est un sous algorithme qui
contient un ensemble d'instructions auquel on associer un nom (IDF) qui à partir de certains
données, elle nous fournit certain nombre de résultats. Ces données et ces résultats sont
appelées Arguments ou Paramètres.

Données Actions paramétrées Résultats

Intérêt de l’A.P:
a)Lisibilité : si l’algorithme trop long ⇒ penser à le décomposer en A.P.
b)Réutisabilité: l’A.P est définie une seul fois est peut être utilisée plusieurs fois.
c)Modifiabilité : il suffit de changer l’A.P sans toucher à l’algorithme principal.

Cette structuration facilite grandement la compréhension d’un algorithme, de même que la

subdivision d’un livre en chapitres et paragraphes simplifie la lecture.

II Déclaration d’une action paramétrée :

L’action paramétrée est constituée de point de vue syntaxique de :

- L’entête : permet de donner un nom (un identificateur) à l’action paramétrée ainsi que la
spécification des paramètres.
- Le corps : comporte une partie déclaration des objets propres à l’action qui peuvent être
des constantes, des types ou des variables. Elle comporte aussi une partie action.

Il existe deux types d’actions paramétrées : les Procédures et les Fonctions.

III Les Procédures :

III.1 Définition :

Une procédure nous permet de désigner par un nom un ensemble d’instructions. Depuis
l’algorithme principal, il suffit d’invoquer ce nom, et les instructions de la procédure seront
exécutées à ce moment.

29
III.2 Syntaxe :

La syntaxe d’une déclaration de procédure est la suivante :

PROCEDURE <identificateur> ;
<partie déclaration de la procédure>
Begin
<instructions>
End ;

La déclaration d’une procédure est donc similaire à la déclaration d’une variable, mais ici
nous déclarons une action, alors que pour une variable nous déclarons une donnée.

Remarques :
• La procédure est placée avant l’algorithme principal.
• Dans le cas ou des paramètres sont associés à la procédure, alors sa déclaration devient :

Procedure <identificateur> (liste de paramètres);

<partie déclaration de la procédure>
Begin
<instructions>
End ;

Exemple de réutilisabilité :

Si on veut tracer 3 lignes d’étoiles

********
********
********
Un traitement et encore 3 lignes d’étoiles
********
********
********
Un autre traitement et encore 3 lignes d’étoiles
********
********
********
Au lieu de répéter plusieurs fois le même traitement, on peut écrire une procédure permettant
de tracer 3 lignes d’étoiles et il suffit de faire appel à cette action autant de fois qu’il est
nécessaire.

III.3 La structure d’un algorithme utilisant une procédure :

30
 En-tête ALGORITHM
En-Tête VAR ….
Déclaration des variables
EEeenN

Déclaration Procedure …
Déclaration des des Var…
Procédures
Procédures Begin
…..
End ;
Corps de l’algorithme
principal Begin
….
End.

Dans un algorithme on parcourt les déclarations de variables puis on passe à l’algorithme

principal. Les noms des procédures permettent déjà de savoir ce qui se passe, sans avoir
besoin de connaître le détail du comment. Ensuite nous pouvons examiner ce que font ces
procédures.

Exemple :
Algorithm Etoile ;
Var i, j : Integer ;
Procedure Etoile3 ;
Begin
For i1 To 3 Do
For j 1 To 10 Do Write(‘ * ‘) Done;
Writeln;
Done ;
End ;
Begin
Etoile3 ;
/*un autre traitement ……….*/
Etoile3 ;
/* un autre traitement……….*/
Etoile3 ;
End.

Au lieu de répéter le bloc d’instruction 3 fois on répète l’appel de procédure 3 fois.

III.4 Les Variables Globales et les Variables Locales :

a) Les variables globales :

Lorsqu’une variable est utilisée par l’algorithme principal, ou par plusieurs procédures, nous
devons la déclarer en tête de l’algorithme. Ces variables sont appelées des variables globales.
Il est souvent conseillé de réduire l’utilisation des variables globales et ceci dans le but de
limiter d’éventuels effets de bord (voir le paragraphe IV).

31
b) Les variables locales :

Les variables déclarées à l’intérieur d’une procédure sont appelées variables locales. Une
variable est déclarée localement car nous n’en n’avons besoin que dans la procédure et elles
ne sont accessibles que par celle-ci.

Remarque : les variables locales ne sont utilisables que dans la procédure où elles sont
déclarées et elles sont créées au moment où nous entrons dans la procédure puis détruites
lorsque nous quittons cette procédure, leur durée de vie est donc celle de la procédure.

Exemple :
Algorithm global_local ;
Var V1 :Integer ;
Procedure P ;
Var V2 :Integer;
Begin
V2 1000 ;
Write(V2) ;
End;
Begin
V1 3 ; P ; Write(V1) ;
End.
Algorithm Variables ;
Var
Val : Integer ;
Procedure P ;
Var
Val : Integer ;
Begin
Val 1000 ;
Write (‘dans la procédure Val= ‘, Val) ;
End;
Begin {Algorithm Principal}
Val 3 ;
P ; {l’appel de la procédure}
Write (‘après l’’appel à la procédure Val= ‘, Val) ;
End.

Remarques :
- L’avantage majeur de la déclaration de variables locales est l’économie de la place
mémoire.
- L’Algorithme principal ne peut pas utiliser les variables locales (elles n’existent pas
lorsque nous sommes dans l’algorithme principal).
- Même si nous avons une variable locale qui a le même nom qu’une variable globale, il ne
s’agit pas de la même zone donc leurs valeurs sont distinctes.

III.5 Les paramètres VALEUR et VARIABLE :

Si on veut tracer trois lignes de dix fois le caractère $, on ne peut pas utiliser (directement) la
procédure etoile3 car elle est figée puisqu’elle ne contient pas de paramètres.

32
Dans la suite de ce chapitre, nous nous intéressons à la déclaration de procédure contenant
une liste de paramètres après le nom de la procédure, comme c’est déjà expliqué dans la
remarque du paragraphe III.2

a) Paramètre VALEUR (Input):

Supposons que nous voulons tracer trois lignes contenant dix fois le caractère * puis trois
lignes de dix fois le caractère $ puis trois lignes de dix fois le caractère #. Au lieu d’écrire
trois procédures, il existe un moyen plus économique, celui d’introduire des paramètres.

Définition :
Pour écrire des procédures d’ordre général, nous utilisons des paramètres. Ces paramètres
permettent de fournir à la procédure la valeur à utiliser pour initialiser les variables, on les
appelle alors des paramètres VALEUR, correspondant au mode de transmission par valeur
encore appelé, le mode Input.
Pour déclarer le paramètre valeur, il suffit de placer le mot clé Input abrégé en (I /) devant
son nom.
En fait nous pouvons aussi appeler la procédure en utilisant comme paramètre valeur, soit des
constantes, soit des variables, ou encore des expressions (par exemple le langage Pascal
évaluera l’expression et initialisera le paramètre de la procédure avec cette valeur).

Exemple :
On veut afficher 3 lignes de 10 (‘*’) puis 3 lignes de M (‘$’) et puis 3 lignes de M+10 (‘#’) ;

Algorithm Parametres ;
Var
M : Integer ;
Procedure dessin (I/ C :character ; I/ X :Integer) ;
Var i, j :Integer ;
Begin

For i1 To 3 Do
For j 1 To X Do Write(C); Done;
Writeln ;
Done ;
Xx+10;
End ;

Begin
Dessin(‘*’,10) ; {constante}
Read(M) ;
Dessin(‘$’,M) ; write(M) {constante et variable}
Dessin(‘#’,M+10) ; {constante et expression}
End.

Remarques :
- Dans le corps de la procédure les paramètres sont utilisés comme si c ‘était des variables
locales. C’est à dire si la valeur du paramètre valeur change dans la procédure, ce
changement n’est pas valable dans l’algorithme principal.
- Lors de l’exécution des instructions de la procédure, les valeurs initiales de ces « variables
locales particulières » sont les valeurs des variables qui sont indiqués au moment de
l’appel.
33
Exemple :
Algorithm parametre_valeur ;
Var
X : Integer ;
Procedure Test (I/ y: Integer);
Begin
yy+10;
Write (y); {ici y=15}
End;
Begin
X5;
Test(X);
Write(X); {ici X=5}
End.

b) Paramètres VARIABLE (paramètre de sortie Output):

Selon l’exemple précédent si on veut modifier la valeur de X, c’est à dire afficher dans
l’algorithme principal la valeur obtenue dans la procédure, il suffit donc de déclarer ce
paramètre en mode Input/Output ou en mode Output en plaçant devant son nom le mot clé
en abrégé (I-O/) ou (O/)Ce type de paramètre s’appelle paramètre variable. C’est en fait, une
transmission par adresse que nous allons expliquer par la suite.

Si nous remplaçons dans l’exemple précédent l’entête de la procédure par :

Procedure Test (I-O/ y :Integer) ;

Lorsque la procédure « Test » est appelée on fournit à la procédure l’adresse de la zone

contenant la valeur de X.

X 44100 Zone Variables Globales

Y 44100 Zone Paramètres et Variables locales

Cette procédure manipule alors directement cette variable. La zone du paramètre contiendra
donc l’adresse de cette variable.
Compte tenu de ce mécanisme, les paramètres variables sont aussi appelés paramètres par
adresse.

34
Remarques :
- On appelle les variables décrites dans l’entête de la procédure les paramètres FORMELS.
- On appelle les variables fournis par l’algorithme appelant lors de l’appel de la procédure
les paramètres EFFECTIFS ou REELS.
- Il doit y avoir une correspondance absolue en nombre, en type et en ordre entre les
paramètres formels et les paramètres effectifs.

Conclusion :
- Le paramètre Valeur IMPORTE dans la procédure une valeur (dont la procédure se sert
pour effectuer ses traitements). I/
- Le paramètre Variable IMPORTE et EXPORTE des valeurs .I-/
Exemple :
Algorithm Parametres ;
Var
x : Integer;
Procedure passage_Valeur (I / y : Integer) ;
Begin
Write (y); 6
yy+4; 10
Write (y) ; 10
End ;

Procedure passage_Variable (I-O/ y :Integer);

Begin
Write (y); 2
yy+5; y=7
Write (y) ; 7
End ;
Begin
x2;
Write (x); 2
passage_Valeur (3*x);
Write(x); /*affiche 2 */ 2
passage_Variable(x);
Write (x); /*affiche 7*/ 7
End.

III.6 Le principe d’appel d’une procédure :

L’appel de procédures est schématisé ci dessous :

Algorithme principal la procédure A

<partie déclaration>
Begin Begin
-----
------
---- End ;
appeler la procédure A ;
-----
-----
----- la procédure B
appeler la procedure B ;
35
 ----- Begin
----
---- End ;
End.

• Imbrication des appels :

Lors d’un appel imbriqué de procédures nous devons respecter les points suivants :
- Respect de transmission des paramètres.
- Respect de retour de l’action appelée vers l’action appelante.
- Chaque action paramétrée doit avoir un début et une fin bien déterminés.
- Une action paramétrée ne peut appeler que les actions qu’elle englobe directement et
celles du même niveau mais déclarés avant elle.

III.7 Emboîtement des actions paramétrées :

1-On peut déclarer plusieurs actions l’une après l’autre ou encore une action à l’intérieure
d’une autre action.
Var
Procédure A ;
Begin
….
End;
Procédure B ;
Begin
….
End;

B peut appeler A mais pas l’inverse.

2- Si une action est à l’intérieure d’une autre action, c’est celle qui est à l’extérieure qui
appelle celle qui est à l’intérieure.

Procedure A ;
Var….
Procedure B ;
Begin /*de B
….
End;
Begin {debut des actions de A}
…. B; …
End;
A peut appeler B.
Procedure A ;
Var ….
Procedure B ;
Var…
Procédure C ;
Begin
….
36
 End;
Begin {parti actions de B}
…C;…
End;
Procedure D ;
Begin
….B; …
End;
Begin {partie actions de A}
…. B; …D; …
End;

L’algorithme principal ne peut appeler que A.

***************************************

IV Les Fonctions :

IV.1 Définition :

Une fonction est une action paramétrée qui rend systématiquement un résultat à travers le
nom de la fonction.

IV.2 Syntaxe :

La déclaration d’une fonction est similaire à celle d’une procédure sauf qu’il faut :
- utiliser Fonction et non pas Procedure.
- indiquer le type de la fonction (c-à-d le type du résultat de la fonction).

FONCTION <nom_identificateur> (liste des paramètres) : <type du résultat> ;

….déclarations
Begin
….actions
End;

Remarques :
- Le résultat peut être de n’importe quel type simple : Integer, Real, Character, Boolean,
chaîne de caractères (mais pas le type structuré comme le type tableau)
- Tout ce qui a été dit au niveau des procédures (variables locales et globales,
paramètres valeur) sont valables pour les fonctions.
- Il ne faut pas oublier d’affecter une valeur à la fonction (identificateur) dans le corps
de la fonction (sinon, l’algorithme retournera n’importe qu’elle valeur (exactement
comme une variable non initialisée).

37
Exemple :
Ecrire une action qui retourne le maximum de deux nombres entiers.

Algorithm traitement_fonction ;
Var
nb1, nb2, Max : Integer ; /* même entête de fonction */
Fonction maximum (E/ n1, n2 : Integer) : Integer ; /* une 2eme possibilité*/
Fonction maximum(n1,n2…
Begin var m :Integer ;
Begin
If (n1>n2) Then maximumn1 If (n1>n2) Then mn1
Else maximumn2; Else mn2;
EIf ; Eif ;
maximumm ; ou return(m) ;
End ; /* fin de fonction*/
End; /* fin de fonction*/

Begin /*de l’algorithme*/

Read(nb1, nb2);
Maxmaximum (nb1, nb2);
Write (Max) ;
End.

Remarque :
1- On peut remplacer les instructions :

Maxmaximum (nb1, nb2);

Write (Max) ;
par
Write (maximum(nb1,nb2)) ;

2- Dans la fonction il ne faut pas utiliser le nom de la fonction dans une évaluation
d’expression (partie droite d’une expression).

Exemple : ecrire un Algorithme qui permet de donner la somme des nombres premiers dans
l’intervalle 1..N .

Algorithm SomPrem ;
…..
Fonction premier(E/x :Integer) :Boolean ;
Var
D,I,m :Integer;
Begin
D0 ;mx DIV 2;
For i2 To m Do
If x Mod i=0 Then DD+1 ; Eif ;
Done;
If D=0 And x<>1 Then premierTrue Else premierFalse ;
Eif ;
End ;

38
Begin
….
S0 ;
For i1 to N Do
If premier(i)=True Then ss+i; Eif;
Done;
…
End.

V Effet de bord :
La communication entre une AP et un Algorithme peut être effectuée de deux manières :
- Une communication explicite à travers la transmission de paramètres par valeur.
- Une communication implicite à travers la transmission des variables globales.

Une communication implicite est moins contrôlable, moins souple car c’est toujours la même
variable qui est utilisée à chaque exécution de l’action paramétrée. Cette méthode nécessite
que l’algorithme appelant connaisse les détails de l’action appelée, sans quoi des erreurs
imprévues peuvent avoir lieu.

Définition : On appelle effet de bord (side effect) les modifications de l’environnement

(local ou global) de l’action paramétrée produite au sein de son exécution, par l’évaluation de
l’expression ou l’exécution d’une instruction. Ces modifications sont en général des
changements de valeurs de variables.

Exemple :

Algorithm side_effect ;
Var
R,V :Integer ;

Fonction diff (I/ X : Integer) :Integer ;

Begin
V V-X ;
diff 2*X ;
End ;

Begin
V 2 ; R diff(2)*diff(V) ; Write (R,V) ; { diff(2)=4, diff (V)=0 résultat (0,0) }
V 2 ; R diff(V)*diff(2) ; Write (R,V) ; { diff(V)=4, diff (2)=4 résultat (16,-2)}
End.

39
VI Les tableaux comme paramètres dans les actions paramétrées :

Ce que nous avons décrit, sur le passage de paramètres simple est valable lorsqu’il s’agit de
types structurés, en particulier, en ce qui concerne le mode de passage (en entrée (I/) ou bien
en entrée/sortie(I_O/)).
Lorsqu’un tableau constitue l’un des paramètres formels de l’action paramétrée.
Sa déclaration étant dans l’entête de l’AP a : Array [1..10] of Integer , est trop longue on la
remplace par une déclaration d’un type défini dans la partie TYPE de l’algorithme.

VI.1 Définition de type structuré :

Considérons l’entête suivante :

Algorithm type_structure ;
Type
vecteur = Array [1..20] of Real ;
Nom = Array [1..10] of Character ;

Var
Notes : vecteur ;
Client : Nom ;

Fonction somme (E/ a : vecteur;) : Boolean ;

Begin
…
End;

Cette entête est équivalente à :

Algorithm type_structure ;
Var
Notes : Array [1..20] of Real ;
Client : Array [1..10] of Character ;

Fonction somme (E/ a : Array[1..20] of Real) :Boolean ;

…
End ;

VI.2 Exemples :

Exemple1 : La somme des éléments d’une matrice d’entiers ;

Algorithm Somme_elements ;
Type
matrice = Array [1..10 ,1..20] of Integer ;
Var
Mat :matrice
40
 Som :Integer ;

Fonction Somme (E/ A :matrice ) :Integer ;

Var
I,J ,S :Integer ;
Begin
S0 ;
For I 1 To 10 Do
For J 1 To 20 Do
S S+A[i,j] ;
Done ;
Done ;
Somme S ; ou return(s) ;
End;

Begin
For i…../*on suppose que lecture de Mat est déjà faite */
For j……

som  somme (Mat) ;

Write (‘la somme est :’, som ); ou Write (‘la somme est :’, somme (Mat) );
End.

Exemple2 : Inverser l’ordre des éléments d’un tableau :

Algorithm inverser_elements ;
Type
Vecteur = Array [1..30] of Real;
Var
T :vecteur ;
I,Taille :Integer ;

Procedure inverser (E/ N :Integer; E_S/ A : vecteur) ;

Var
I, m : Integer ; X :Real ;
Begin
M N Div 2;
For I 1 To m Do
If (I<N-I+1) Then
X A[I] ; A [I]  A[N-I+1]; A[N-I+1] X ;
Eif ;
Done;
End ;

Begin
Read (taille) ;
For I 1 To taille Do Read( T[I] ); Done ;
inverser (taille, T) ;
For I 1 To taille Do Write (T[I]) ; Done ;
End.

41