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 Pb initial est une
suite ordonnée des sous algorithmes de résolution de tous les sous Pbs (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 à la 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>
debut
<instructions>
fin ;

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>
debut
<instructions>
fin ;

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 ALGORITHME………
En-Tête VAR ….
Déclaration des variables
EEeenN

Déclaration Procedure …
Déclaration des des
Procédures
Procédures debut
…..
fin ;
Corps de l’algorithme
principal debut
….
fin.

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 :
Algorithme Etoile ;
Var
i, j : entier ;
Procedure Etoile3 ;
debut
Pour i1 à 3
faire
Pour j 1 à 10 faire ecrire(‘ * ‘) ; fait;
fait ;
fin ;
debut
Etoile3 ;
/*traitement ……….*/
Etoile3 ;
/*traitement……….*/
Etoile3 ;
Fin.

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).

b) Les variables locales :

31
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 :
Algorithme global_local ;
Var
V1 :entier ;
Procedure P ;
Var V2 :entier;
debut
V2 1000 ;
ecrire(V2) ;
Fin;
debut
V1 3 ; P ; ecrire(V1) ;
fin.

Algorithme Casse-cou ;
Var
Val : entier ;
Procedure P ;
Var
Val : entier ;
debut
Val 1000 ;
ecrire (‘dans la procédure Val ‘, Val) ;
Fin;
debut {Algorithme Principal}
Val 3 ;
P ; {l’appel de la procédure}
ecrire (‘après l’appel à la procédure Val ‘, Val) ;
fin.
*****************************************************************mercredi
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 :
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 Entrée.
Pour déclarer le paramètre valeur, il suffit de placer le mot clé Entrée abrégé en (E /) 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 (qui est évaluée puis initialisée)

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

Algorithme Paramètre ;
Var
M : entier ;
Procedure dessin (E/ C :caractère ; E/ X :entier) ;
Var i, j :entier ;
debut
Pour i1 à 3
faire
Pour j 1 à X faire écrire (C) Fait;
fait ;
fin ;
debut
dessin(‘*’,10) ; {appel avec constante}
lire(M) ;
dessin(‘$’,M) ; { appel variable}
dessin(‘#’,M+10) ; {expression}
fin.

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.

Exemple :
Algorithme paramètre_valeur ;
Var
X : entier ;
33
 Procedure Test (E/ y: entier);
debut
yy+10;
écrire (y); {ici y=15}
fin;
debut
X5;
Test(X);
ecrire(X); {ici X=5}
Fin.

b) Paramètres VARIABLE :

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 Entrée/Sortie en plaçant devant son nom le mot clé en abrégé (E-S/) 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 (E-S/ y :entier) ;

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.

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.
34
- 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). E/
- Le paramètre Variable IMPORTE et EXPORTE des valeurs.E-S/

Exemple :
Algorithme paramètre ;
Var
x : entier ;
Procedure passage_Valeur (E / y : entier) ;
debut
ecrire (y); 6
yy+4; 10
ecrire (y) ; 10
Fin ;

Procedure passage_Variable (E-S/ y :entier);

Début
ecrire (y); y= 2
yy+5; y= 7
ecrire (y) y= 7
Fin ;

debut
x2;
ecrire (x); x= 2
passage_Valeur (3*x);
ecrire(x); /*affiche 2*/ x= 2
passage_Variable(x);
Écrire (x); /*affiche 7*/ x=7
fin.

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

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

35
 Algorithme principal la procédure A
<partie déclaration>
debut début
-----
------
---- fin ;
appeler la procédure A ;
-----
-----
----- la procédure B
appeler la procedure B ;
----- début
----
---
---- fin ;
Fin.

 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 ;
début
….
Fin;
Procédure B ;
début
….
Fin;

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.

36
 Procedure A ;
Var….
Procedure B ;
Début /*de B
….
Fin;
debut {debut des actions de A}
…. B; …
fin;

Procedure A ;
Var ….
Procedure B ;
Var…
Procédure C ;
debut
….
fin;
debut {parti actions de B}
…C;…
fin;
Procedure D ;
debut
….B; …
fin;
debut {partie actions de A}
…. B; …D; …
fin;

L’algorithme principal ne peut appeler que A.

***********************************************************lundi

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 Procédure
- 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> ;

….declarations
37
 debut
….actions
fin ;

Remarques :
- Le résultat peut être de n’importe quel type simple : entier, réel, caractère, booléen,
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)

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

Algorithme traitement_fonction ;
Var
nb1, nb2, Max : entier ;
Fonction maximum (E/ n1, n2 : entier) : entier ; /* une 2eme possibilité*/
debut var m :entier ;
debut
si (n1>n2) alors maximumn1 si (n1>n2) alors mn1 ;
Sinon maximumn2; Sinon mn2;
fsi ; fsi ;
fsi ; maximumm ; ou retourne(m) ;
fin;

debut
lire (nb1, nb2);
Maxmaximum (nb1, nb2);
ecrire (Max) ;
Fin.

Remarque :
1- On peut remplacer les instructions :

Maxmaximum (nb1, nb2);

ecrire (Max) ;
par
ecrire (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).
3-

V Effet de bord :
La communication 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.
38
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 :

Algorithme side_effect ;
Var
R,V :entier ;
Fonction diff (E/ X : entier) :entier ;
debut
V V-X ;
diff 2*X ;
fin ;

debut
V 2 ; R diff(2)*diff(V) ; ecrire (R,V) ; { diff(2)=4, diff (V)=0 résultat (0,0) }
V 2 ; R diff(V)*diff(2) ; ecrire (R,V) ; { diff(V)=4, diff (2)=4 résultat (16,-2)}
Fin.

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 ou bien en
entrée/sortie).
Lorsqu’un tableau constitue l’un des paramètres formel de l’action paramétrée.
sa déclaration étant dans l’entête de l’AP a : tableau [1..10] d’entier , 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 :

Algorithme type_structuré ;
Type
vecteur = tableau [1..20] de réel ;
Nom = tableau [1..10] de caractère ;

Var
Notes : vecteur ;
Client : Nom ;

Fonction somme (E/ a : vecteur) :booléen ;

debut
39
…
fin ;

Cette entête est équivalente à :

Algorithme type_structuré ;
Var
Notes : tableau [1..20] de réel ;
Client : tableau [1..10] de caractère ;

Fonction somme (E/ a : tableau[1..20] de réels) :booléen ;

…
fin ;

VI.2 Exemples :

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

Algorithme Somme_éléments ;
Type
matrice = tableau [1..10 ,1..20] d’entier ;
Var
Mat :matrice
Som :entier ;

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

Var
I,J ,S :entier ;
debut
Pour I 1 à 10 faire
Pour J 1 à 20 faire
S S+A[i,j] ;
Fait ;
Fait ;
Somme S ;
Fin ;

DEBUT
/*on suppose que lecture de Mat est déjà faite */
som  somme (mat) ;
ecrire (‘la somme est :’, som );
FIN.

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

Algorithme inverser_éléments ;
Type
Vecteur = tableau [1..30] de réels;
Var
40
 T :vecteur ;
I,Taille :entier ;

Procédure inverser (E/ N :entier ; E_S/ A : vecteur) ;

Var
I :entier ; X :réel ;
debut
Pour I 1 à N div2 faire
si (I<>N-I+1) alors
X A[I] ; A [I]  A[N-I+1]; A[N-I+1] X ;
Fsi ;
Fait ;
Fin ;

debut
Lire (taille) ;
Pour i 1 à taille faire lire( T[I] ); fait ;
inverser (taille, T) ;
Pour i 1 à taille faire écrire (T[I]) ; fait ;
FIN.

41