cours numéro 11

Admin Age : 47 Inscrit le : 15 Mar 2008 Messages : 22

5) Le passage des paramètres :

Il existe deux manières d'échange des données entre une procédure et le programme qui l'appelle

* A l'aide des variables globales: c'est ce que nous avons fait jusqu'à maintenant. Cette méthode ne permet pas de faire vraiment de la programmation paramétrée. Si on revient au premier exemple et on considère que l'on a deux factions à réduire ( A/B ET E/F), l’utilisation de la procédure « Reduction » telle qu'elle est écrite nécessite une manipulation assez délicate.

* A travers des arguments transmis à la procédure au moment de l'appel. Ceci va nous permettre de paramétrer la procédure pour permettre une utilisation plus simple de la procédure en question.

Le programme du premier exemple (réduction de fraction) peut être réécrit comme suit:

Program PremiereProcedure;
Var
A, B : Integer ; (* Variables globales *)
Procedure Reduction (var X :Integer ; var Y: Integer) ;
Var
D : Integer ; (* Variables locales à la procédure Reduction *)
T1, T2: Integer;
Begin
(*copie des valeurs de X et Y*)
T1 := X ;
T2 := Y ;
(*Calcul de PGCD de T1 et T2*)
Repeat
D := T1 mod T2 ;
T1 := T2 ;
T2:=D
Until D=0 ;
(* Réalisation de la réduction *)
X := X div T1 ;
Y := Y div T1
End; (* Fin de le procédure Réduction*)
Begin (* Début. du programme principal *)
Writeln ('Donner la fraction A/B :') ;
Readln (A, B) ;
(* Appel de la procédure Reduction *)
Reduction (A B);
(* Affichage du résultat *)
Writeln (‘La réduction de la fraction A/B a donné :’ A, ‘/’,B) ;
End. (* Fin du programme principal *)

Remarqes:
* Les variables (X, Y) de la procédures « Reduction » sont les paramètres formels de la procédure.
* Lors de l'appel de la procédure, les paramètres (A ,B) sont appelés les paramètres effectifs.
* Il est évident, que dans cette nouvelle formulation, il est possible d'appeler la même procédure (reduction) pour réduire d'autres fractions en ajoutant simplement un appel de la procédure avec d'autres paramètres effectifs.
* Lors de l'appel de la procédure on dit qu'un passage de paramètres a eu lieu. Les paramètres formels deviennent alors des paramètres effectifs pour lesquels la procédure va être exécutée.

Pascal permet deux modes de passage de paramètres: le passage des paramètres par adresse (par référence où par variable) et le passage de paramètres par valeur.
a) Passage de paramètre par adresse:

Un paramètre est passé par adresse s'il est précédé du mot 'Var' dans la définition de la procédure (voir l'exemple réduction d'une fraction). Dans ce cas, le passage de paramètre lors de l'appel se passe comme suit:
* Le paramètre effectif doit être obligatoirement une variable de même type que le paramètre formel.
* Le paramètre formel et le paramètre effectif représentent alors deux identificateurs de la même variable, et toute manipulation du paramètre formel est en fait une manipulation du paramètre effectif. On dit aussi que le paramètre formel devient un alias du paramètre effectif.
* Lors de la fin d'exécution de la procédure, le paramètre effectif garde la dernière valeur qui lui a été affectée pendant l'exécution de la procédure en question.

* Le passage d'un paramètre par adresse permet au programme appelant de communiquer une valeur à la procédure, et à la procédure de communiquer un résultat.

Exemple : program PassageParAdresse;
Var Pe : Integer ; Procédure Proc (var Pf: Integer) ;
Begin
Write (Pf) ;
Pf := Pf + 1 ;
Write (Pf) : ;
End ;
Begin
Pe:= 0 ;
Write (Pe) ;
Proc (Pe) ;
Write (Pe) ;
End.
Lors de son exécution, ce programme affichera les valeurs 0 0 1 1.

b) Le passage de paramètres par valeur :

Un paramètre est passé par valeur s'il n'est pas précédé du mot 'var' dans la définition de la procédure. Dans ce cas, le paramètre lors de l'appel se passe comme suit:

* Le paramètre effectif doit être une expression de type compatible avec le paramètre formel.

* Le paramètre formel se comporte exactement comme une variable locale de la procédure.

* Avant l'exécution de la première instruction de la procédure, la valeur du paramètre effectif est affectée au paramètre formel.

* La manipulation du paramètre formel pendant l'exécution de la procédure n'affecte en rien le paramètre effectif.

*Le passage d'un paramètre par valeur permet au programme appelant de communiquer une valeur à la procédure, mais ne permet pas à la procédure de communiquer un résultat à travers ce paramètre.

Exemple: On peut reprendre l'exemple précédent en utilisant un passage de paramètre par valeur.

Program PassageParValeur;
Var
Pe : Integer ;
Procédure Proc (Pt: Integer) ;
Begin
Write (Pf) ;
Pf := Pf + 1 ;
Write (Pf) ;
End;
Begin
Pe:=0;
Write (Pe) ;
Proc (Pe) ;
Write (Pe) ;
End.

Lors de son exécution, ce programme affichera les valeurs 0 0 1 0,