Pascal-7 (c) Dr M.Ziade'. FACULTE DE GENIE, Liban. Faculty of Engineering, Lebanon. Dr M.Ziadé. Faculté de Génie, ingénieur. Universite Libanaise

www.facultedegenie.net SITE INDEPENDANT (non-officiel) FACULTE DE GENIE (LIBAN) Faculty of Engineering (Lebanon)	(Ad/info)
Zone PROF - Zone INGENIEUR - Zone ETUDIANT - Zone VISITEUR	Next Page N.117

* Guest-Book *
* News-Group *
Suggest update

f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

w
w
w
.
f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

g
r
o
u
p
.
f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

w
w
w
.
f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

g
r
o
u
p
.
f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

Informatique : PASCAL (Chapitre VII)

FONCTIONS, PROCEDURES, RECURSIVITE
© Dr Mustapha ZIADE'

This text copyright = www.ziade.net
Ce texte vient de © www.ziade.net

(VII.1) Fonctions (définies par l'utilisateur)

Nous avons vu que le Pascal possède des fonctions prédéfinies (comme: EXP, LN, SIN, …). Le programmeur peut aussi créer des nouvelles fonctions, elles sont dites ''définies par l'utilisateur''.

(VII.1.a) Déclaration d'une fonction (non prédéfinie)

Voici un exemple simple d'une fonction SIGNE définie par l'utilisateur:

FUNCTION SIGNE ( X : REAL ) : INTEGER ;
BEGIN
IF X<0 THEN SIGNE := -1 ; { le IF…THEN… se termine dès le ; }
IF X=0 THEN SIGNE := 0 ;
IF X>0 THEN SIGNE := 1 ;
END ; { fin de la fonction }

*** Important 1:
• il faut spécifier le type de(s) paramètre(s) et le type du résultat de la fonction.

Dans l'exemple ci-dessus (cas particulier):
- il y a un seul paramètre X qui est de type réel,
- le résultat de la fonction est de type entier.

*** Important 2:
• une fonction peut avoir plusieurs paramètres de types différents,
• le résultat d'une fonction est toujours unique et de type simple.

Voici un exemple d'une fonction ayant plusieurs paramètres (ici ils sont deux):

FUNCTION MAXI ( X , Y : REAL ) : REAL ;
BEGIN { le IF…THEN…ELSE… se termine dès le ; }
IF X>=Y THEN MAXI := X ELSE MAXI := Y ;
END ; { fin de la fonction }

Voici un exemple d'une fonction ayant des paramètres de types différents:

FUNCTION BASCULE ( X , Y : REAL ; N : INTEGER ) : REAL ;
BEGIN
IF N>=0 THEN BASCULE := X ELSE BASCULE := Y ;
END ; { fin de la fonction }

*** Important 3:
• une fonction peut utiliser une fonction prédéfinie ou une fonction déjà déclarée.

Voici un exemple d'une telle fonction (SINE donnera: [sin(x)/x] si [sin(x)/x]>0, et 0 sinon) :

FUNCTION SINE ( X : REAL ) : REAL ;
BEGIN
IF X<>0 THEN SINE := MAXI ( SIN(X)/X , 0 ) ELSE SINE := 1 ;
END ; { fin de la fonction }

*** Important 4:
• les paramètres sont des ''variables muettes'' (ce ne sont pas de vraies variables),
• il n'y a pas de correspondance directe entre les paramètres et les variables déclarées.
(au départ de la fonction: la variable est copiée dans le paramètre, voir §1.c ci-dessous).

(VII.1.b) Utilisation d'une fonction (non prédéfinie)

Une fois déclarée, une fonction définie par l'utilisateur s'utilise de la même façon qu'une fonction prédéfinie (comme EXP, SIN, …). Par exemple:
Z := EXP(1) ;
X := 3 * SIN(Z) ;
Y := 3 * SIGNE(Z) ;

(VII.1.c) Qu'est ce qu'un paramètre ?

Revenons à la fonction suivante (définie par l'utilisateur) :

FUNCTION SIGNE ( X : REAL ) : INTEGER ;
BEGIN
IF X<0 THEN SIGNE := -1 ; { les IF…THEN… se terminent dès le ; }
IF X=0 THEN SIGNE := 0 ;
IF X>0 THEN SIGNE := 1 ;
END ; { fin de la fonction }

Le paramètre de cette fonction est X.
Ce paramètre X n'est pas confondu avec la variable X.

En effet, si nous exécutons (dans le corps du programme) les trois instructions

X := 5 ;
Y := SIGNE(7) ;
WRITELN ( ' X = ' , X , ' et Y = ' , Y ) ;

nous obtenons à l'affichage:
X = 5 et Y = 1
ce qui nous démontre que le paramètre X n'est pas confondu avec la variable X (voir aussi §5).

Remarquons que si le paramètre X avait été confondu avec la variable X, alors nous aurions obtenu l'affichage suivant: X = 7 et Y = 1
ce qui n'a pas lieu en Pascal.

*** On dit que les paramètres sont passés par valeur c'est-à-dire que le compilateur passe à la fonction la valeur du paramètre (ou photocopie), mais ne passe pas la variable (en tant que variable).

(VII.1.d) Partie déclarative locale (dans une fonction)

Une fonction peut contenir une partie déclarative (voir la partie déclarative d'un programme). Cette partie déclarative est locale c'est-à-dire que ce qui est déclaré existe seulement pendant l'exécution de la fonction (ensuite les variables locales sont oubliées).

PROGRAM FACTORIELLE ;
VAR K : integer ; { partie déclarative globale }

FUNCTION FACTO ( N : integer ) : integer ;
VAR i , accu : integer ; { partie déclarative locale }
BEGIN
accu := 1 ;
for i := 1 to N do
begin accu := accu * i ;
end;
facto := accu ;
END ; { fin de la fonction }

BEGIN { corps du programme }
FOR K := 1 TO 10 DO
BEGIN
WRITELN( K , ' ! = ' , FACTO(K) ) ; { ici write(accu) est impossible }
END ;
END.

Dans le programme précédent, les variables locales (i et ACCU) sont utilisables seulement dans la fonction dans laquelle elles sont déclarées, ensuite ces variables sont oubliées. Il en est de même pour toutes les déclarations locales qui sont utilisables seulement dans la fonction (ou dans la procédure) dans laquelle elles sont déclarées, ensuite ces déclarations sont oubliées.
Par exemple: une constante locale est utilisable localement, mais elle ne peux pas être utilisée dans le corps du programme.

(VII.2) Procédures (définies par l'utilisateur)

Nous avons vu que le Pascal possède des procédures prédéfinies (comme: WRITELN, …).
Le programmeur peut aussi créer des nouvelles procédures, elles sont dites ''définies par l'utilisateur''.

(VII.2.a) Déclaration d'une procédure (non prédéfinie)

Voici un exemple simple d'une procédure CARRE définie par l'utilisateur:

PROCEDURE CARRE ( X : REAL ) ;
BEGIN
writeln( sqr(X) , ' est le carré de ' , X ) ;
END ; { fin de la procédure }

(VII.2.b) Utilisation d'une procédure (non prédéfinie)

Une fois déclarée, une procédure définie par l'utilisateur s'utilise de la même façon qu'une procédure prédéfinie (comme: writeln, readln, …). Par exemple:
readln(X) ; CARRE(X) ;

ATTENTION: le nombre, l'ordre et le type des paramètres déclarés doivent être respectés.

Les exemples suivants sont impossibles:
CARRE(X,Y) ; { err: le nombre de paramètres n'est pas respecté }
CARRE ; { err: il n'y a pas de paramètre }
CARRE( 'X' ) ; { err: le type n'est pas respecté ('X' est une lettre) }

(VII.2.c) Comment obtenir des résultats ?

Une procédure peut donner: un résultat de type non simple (comme un tableau), ou un résultat de type ''non prédéfini'' (c'est-à-dire défini par l'utilisateur), ou plusieurs résultats.

Mais une procédure ne donne pas une valeur (contrairement à une fonction qui donne une valeur).

Les résultats sont obtenus grâce aux ''paramètres passés par variable'' c.-à-d. ''paramètres passés par adresse'' qui sont appelés ''paramètres de sortie''.
Tandis que les ''paramètres passés par valeur'' sont appelés ''paramètres d'entrée''.

Dans l'exemple ci-dessous, les résultats ou paramètres de sortie sont B et TRACE (car passés par adresse ou par variable à cause du mot clé VAR), tandis que le(s) paramètre(s) d'entrée est A.

PROGRAM PRO ;
CONST Nmax = 3 ;
TYPE Tmatrice = array [ 1 . . Nmax , 1 . . Nmax ] of real ;
VAR
mat : Tmatrice ;
m , n : integer ;
X : real ;

PROCEDURE TRANSPOSE ( A : Tmatrice ; VAR B : Tmatrice ; VAR trace : real ) ;
{ entrée: matrice A }
{ sortie: matrice B = transposée de A }
{ sortie: TRACE = trace de A (et B) }
BEGIN
trace := 0 ;
for m := 1 to Nmax do
begin
for n := 1 to Nmax do
begin B[m,n] := A[n,m] { B est la transposée de A }
end ;
trace := trace + A[m,m]
end ;
END ; { fin de la procédure }

BEGIN { corps du programme }
… { il faut initialiser (donner) tous les éléments de la matrice MAT }
TRANSPOSE ( MAT , MAT , X ) ;
… { les … sont à remplacer par des instructions }
END.

Dans l'exemple ci-dessus les paramètres (A et B) ne sont pas déclarés au début du programme.

Important 5:
• il n'y a pas de correspondance directe entre les paramètres et les variables déclarées,
donc il n'est pas nécessaire de déclarer les paramètres au début du programme.

(VII.3) Différences entre ''paramètres passés par valeur'' et ''paramètres passés par variable (ou par adresse)''

Revenons à l'exemple précédent (très instructif au sujet des paramètres) :

- La matrice A est un ''paramètre passé par valeur'', donc quand le programme appelle la procédure TRANSPOSE(MAT, MAT, X) le compilateur va travailler sur le paramètre A qui est une copie de la matrice MAT.

- La matrice B est un ''paramètre passé par variable (ou par adresse)'', donc quand le programme appelle la procédure TRANSPOSE(MAT, MAT, X) le compilateur va travailler sur le paramètre B qui est alors la variable MAT.

*** Important 6:
• le compilateur travaille sur une copie des ''paramètres passés par valeur'' (sans VAR),
• le compilateur travaille directement sur les ''paramètres passés par variable'' (avec VAR).

L'exemple suivant a pour but de bien montrer la différence entre ''paramètre passé par valeur'' et ''paramètre passé par variable''.

PROGRAM FOLKLORE ;
VAR X , Y : integer ;

PROCEDURE ESSAI ( X : integer ; VAR Y : integer ) ;
BEGIN
X := 3 ; Y := 4 ;
writeln ( ' Dans la procédure: X = ' , X , ' et Y = ' , Y ) ;
END;

BEGIN { corps du programme }
X := 1 ; Y := 2 ;
writeln ( ' Avant la procédure: X = ' , X , ' et Y = ' , Y ) ;
ESSAI ( X , Y ) ;
writeln ( ' Après la procédure: X = ' , X , ' et Y = ' , Y ) ;
END.

A l'exécution de ce programme, nous obtenons l'affichage suivant:
Avant la procédure: X = 1 et Y = 2
Dans la procédure: X = 3 et Y = 4
Après la procédure: X = 1 et Y = 4

Donc les modifications des ''paramètres passés par valeur'' sont oubliées à la sortie de la procédure, tandis que les modifications des ''paramètres passés par variable (ou par adresse)'' vont rester.

(VII.4) Différences entre ''variables globales'' et ''paramètres passés par variable''

Nous avons vu que les paramètres sont des ''variables muettes'' et que compilateur travaille directement sur les ''paramètres passés par variable''. Considérons le programme suivant:

PROGRAM DISTINGUER ;
VAR X , ALPHA : integer ;
{ X et ALPHA sont déclarées variables globales }

PROCEDURE BIDULE( VAR X : integer ) ;
{ dans la procédure X est un paramètre }
BEGIN
X := 9 ;
writeln( ' Dans la procédure la valeur du paramètre est ' , X ) ;
END ;

BEGIN { corps du programme }
X := 1 ; ALPHA := 5 ;
writeln( ' Avant la procédure X = ' , X , ' et a = ' , ALPHA ) ;
BIDULE(ALPHA) ;
writeln( ' Après la procédure X = ' , X , ' et a = ' , ALPHA ) ;
END.

Nous obtenons l'affichage suivant:
Avant la procédure X = 1 et a = 5
Dans la procédure la valeur du paramètre est 9
Après la procédure X = 1 et a = 9

Donc dans la procédure: X est le paramètre, ce n'est pas la variable globale X.

Pour cette raison à l'exécution de l'instruction BIDULE(ALPHA); le compilateur va travailler directement sur la variable ALPHA qui est le '' paramètre passé par variable ''.
En effet, dans la procédure: X est une '' variable muette '' c'est-à-dire que ce n'est pas une vraie variable.

Dans cette procédure: X est le paramètre, simplement car X est déclaré paramètre dans la procédure.
(Remarque: il est clair que durant une instruction BIDULE(X); le paramètre est la variable globale.)

(VII.5) Différences entre ''variables globales'' et ''paramètres passés par valeur''

Nous avons vu que les paramètres sont des ''variables muettes'' et que le compilateur travaille sur une copie des ''paramètres passés par valeur''. Il suffit de reprendre l'exemple ci-dessus en enlevant le mot réservé VAR dans la déclaration de BIDULE alors X devient un ''paramètre passé par valeur'' dans la procédure.

PROCEDURE BIDULE( X : integer ) ;
...
BEGIN
…
END;

Cette modification donne l'affichage suivant:
Avant la procédure X = 1 et a = 5
Dans la procédure la valeur du paramètre est 9
Après la procédure X = 1 et a = 5

En effet, un ''paramètre passé par valeur'' est une copie de la variable (d'appel).

(VII.6) Différences entre variables globales et variables locales

Nous avons vu que les variables globales sont déclarées au début du programme, et que nous pouvons faire des déclarations locales donc nous pouvons avoir des variables locales (dans une fonction ou une procédure). Considérons le programme suivant:

PROGRAM DISTINCTION ;
VAR N : integer ; { N est déclarée variable globale }

PROCEDURE MACHIN ;
VAR N : integer ;
{ dans la procédure N est une variable locale (non globale) }
BEGIN
N := 9 ;
writeln( ' Dans la procédure N = ' , N , ' (var. locale) ' ) ;
END ;

BEGIN
N := 1 ; writeln( ' Avant la procédure N = ' , N , ' (var. globale) ' ) ;
MACHIN ;
writeln( ' Après la procédure N = ' , N , ' (var. globale) ' ) ;
END.

Nous obtenons l'affichage suivant:
Avant la procédure N = 1 (var. globale)
Dans la procédure N = 9 (var. locale)
Après la procédure N = 1 (var. globale)

Donc dans la procédure: N est une variable locale, ce n'est pas la variable globale N.

Pour cette raison à l'exécution de l'instruction MACHIN; le compilateur va travailler sur une nouvelle variable N qui est une ''variable locale'', c'est-à-dire que cette nouvelle variable n'existera que pendant la procédure et ce n'est pas la ''variable globale'' N.

Dans la procédure: N est une variable locale, simplement car N est déclaré locale dans la procédure.

(VII.7) Récursivité (fonction ou procédure récursive)

Une fonction ou une procédure est dite récursive si elle s'appelle elle-même. Par exemple:

FUNCTION FAC ( N : integer ) : integer ;
BEGIN
IF N<2 THEN FAC:=1 ELSE FAC := N * FAC(N-1) ;
END ;

L'idée vient de l'égalité: N! = N * (N-1)! qui implique que la valeur de FAC(N) est N * FAC(N-1). D'où l'écriture de cette fonction { car le FAC situé à gauche dans FAC := N * FAC(N-1) est la valeur de FAC(N) puisque le paramètre de FAC est N }.

La fonction FAC est récursive car elle utilise FAC(N-1) pour calculer FAC(N).

La récursivité est naturellement possible car le Pascal utilise des paramètres.

Voici un exemple d'une procédure récursive:

PROGRAM HEXADECIMAL ;

PROCEDURE BASE16H ( N : integer ) ;
{ revoir le §II.10 à propos de l'hexadécimal }
BEGIN
IF N>0 THEN
BEGIN
BASE16H( N div 16 ) ;
CASE (N mod 16) OF
0 . . 9 : write( N mod 16 ) ; { write ne change pas de ligne }
ELSE write( chr( (N mod 16) - 10 + ord('A') ) ) ;
end ; { fin du CASE }
END ; { fin du IF }
END ; { fin de la procédure }

BEGIN
writeln( ' En hexadécimal (base 16) le nombre 255 se note ' );
BASE16H(255);
END.

Cet exemple illustre bien l'avantage et le principe de la récursivité: il suffit de savoir comment ramener le cas général (entier positif quelconque) à un cas simple (entier de 0 à 15) qu'on sait faire facilement.

ATTENTION: IL FAUT TOUJOURS PREVOIR UN TEST POUR FINIR LA RECURSIVITE.

(I) Introduction Générale

(II) Erreurs ou Limites des Calculs Numériques et informatiques *****

(III) Types, Opérateurs, Fonctions et Procédures prédéfinis

(IV) Partie Déclarative d'un programme

(V) Structure d'un programme

(VI) Affectations, Tests, Boucles

(VII) Fonctions, Procédures, Récursivité

(VIII) Fichiers Textes, Fichiers Binaires

(IX) Pointeurs

(i) Faculté de Génie, Liban