cours numéro 12

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

6) Les effets de bord :

Lorsqu'une procédure (ou fonction) modifie une variable non locale, on dit qu'elle a un effet de bord (ou effet secondaire). Il est généralement conseillé aux programmeur d’éviter ce genre de situation parce que ceci entraîne souvent une difficulté à lire et à contrôler le programme en question. Il est donc préférable d'exploiter les deux modes de passage de paramètres (Par valeur ou par adresse) comme unique moyen de communication entre un programme appelant et une procédure. Plus précisément, il faut éviter la communication entre un programme et un autre via les variables globales.

Exemple: Program EffetDeBord;
Var
A: Real;
Procedure Exemple (var X : Real) ;
Var B: Real;
Begin
B := 130 ;
A := B*2 ;
X := X + A
End;
Begin
A:= 21.5;
Exemple (A) ;
Writeln (A)
End.

7) Les fonctions:
Une fonction peut être considérée comme un cas particulier d'une procédure, dans le sens où une fonction retourne toujours une valeur unique et peut avoir autant d’arguments que nécessaire.

Exemple : calcul du PGCD de deux entiers.
Program Exempledefonction ;
Var
A, B, P : Integer ;
Function PGCD (P: Integer; Q : Integer) : Integer;
Var
D: Integer;
Begin
Repeat
D := P mod Q ;
P:=Q;
Q:=D
Until D=0;
PGCD := P;
End;
Begin
Writeln (’Donner les entiers A et B: ') ;
Readln (A,B) ;
P := PGCD (A,B) ;
Writeln (‘Le PGCD de A et B est:’, P)
End.

A travers cet exemple simple nous pouvons énumérer les règles générales de déclaration et d’utilisation des fonctions :
* La déclaration d'une fonction comporte ob1igatoirement la précision du type de la fonction. Ce type représente le type du résultat retourné par la fonction.
* Le type de la fonction doit être un type simple.
* Le corps de la fonction doit obligatoirement comporter une instruction de retour du résultat.

Cette instruction se note comme une affectation dont le membre gauche est exactement le nom de la fonction. C'est généralement la dernière instruction exécutée de la fonction.

* Contrairement à l'appel d'une procédure, l'appel d'une fonction ne peut pas constituer une instruction. Un appel de fonction est généralement placé dans une expression.

Cool

Règles générales concernant l'écriture de procédures et fonctions:

Bien que la structuration dès programmes en blocs soit une bonne manière d’écriture de programme, il faut cependant respecter un certain nombre de règles dont voici les principales:

b) Procédures (fonctions) imbriquées:

Le bloc d'une procédure (ou fonction) peut contenir à son tour la définition d'une autre procédure (ou fonction). Dans ce cas les règles à respecter sont:

· L'identificateur d'une procédure (ou fonction) doit être différent de l'identificateur de tout autre objet du bloc en question.

Exemple : Tri d'un tableau d'entiers par ordre croissant, en utilisant la méthode de tri par bulles.

Program Procedures_lmbriquees;

Const
Taille=20 ;
Type
Indice = 1..Taille ;
Vecteur = array [Indice] of integer;
Var
V : Vecteur;
N : Indice ;
Procedure Lire_Vecteur (var T: Vecteur; var m : Indice) ;
Var
I: Indice;
Begin
Writeln (‘Donner le nombre de composantes du vecteur: ') ;
Readln (m) ;
Writeln (‘Donner les composantes du vecteur :') ;
For I:= 1 to m Do
Read (T[I]);
End; (* Lire_Vecteur *)
Procedure Afficher-Vecteur (T : Vecteur; m : Indice) ;
Var
I: Indice;
Begin
For I := 1 To m Do Writeln(‘T’,I, '=', T[i])
End; (* proc Afficher_Vecteur *)
Procedure Tri_Vecteur (var T: Vecteur; m: Indice) ;
Var
I , J : Indice;
Procedure Permutation (K:Indice; L:Indice);
Var
Temp: Integer;
Begin
Temp := T[K]: T[k] := T(L]; T[L]:= Temp
End; (* Proc Permutation')
Begin For I :=1 To m-1 Do For J :=1+1 To m Do If T[I] > Tm Then Permutation(I, J)
End; (* proc Tri_Vecteur *)
Begin (* Programme Principal *)
Lire-Vecteur(V, N) ;
Tri_Vecteur(V, N) ;
Affichage_Vecteur(V, N)
End.

b) Appel d’une procédure par une autre procédure :

Nous avon1J déjà eu l’ocasion de voir une procédure (ou fonction) appeler une autre. Néanmoins ce genre d'appel obéi aux gègles suivantes, :

1. Une procédure (ou fonction) A peut appeler n'importe quelle autre procédure (ou fonction) B qui vérifie l'une des deux conditions suivantes :
*La procédure B est définie directement dans le bloc A.
* Le bloc , dans lequel la procédure B est définie contient le bloc dans lequel la procédure A est
Définie (on dit que B est visible à partir de A).

Program EssaiAppel
Procedure ;
procedure A;
………….
Procedure B;
…………….
Begin
……….
End;
Begin
…………
End;
Proc:dure D;
……………….
Procedure C;
………………
Proœdure E;
....................
Begin
A;
B;
End;
………….
Begin
…………
D;
A;
E;
..............
End;
Begin
E;
B;
End;
Procedure F;
Begin
C;
A;
End;
Begin

End;

2. Un apppel d'une procédure se situe généralement après sa définition, dans ce cas le compilateur n'a aucun problème pour vérifier les paramètres de l' appel, Si par contre, on veut permettre l'appel d'une procédure P avant sa définition on doit écrire la ligne suivante au début de la section de déclaration de procédure et fonctions :

Procedure P ; Forward ;

Cette ligne précise au compilateur que la procédure A sera appelée avant sa définition. En même temps, elle permet au compilateur de réaliser l’opération de vérification des paramètres lors de l’appel.

Exemple : Program EssaiAppel ;
……………………….
Procedure A ;
……………..
Begin
……………….
B ;
……………….
End ;
Procedure B ;
……………… …..
Begin
…………. ………….
End ;
Procedure C ;
…………….
Begin
…………..
A ;
……………..
End;
Begin
……………
……………
End.

Invité

Program ex04 ;
Var bool :boolean ;
N :integer ;
Procedure premier(var a :integer) ;
Var
I :integer ;
begin
bool:=false;
i:=2;
repeat
if(a mod i)=0 then
bool:=true
else
i:=i+1;
until (bool=true)or(i>(a mod i));
end;
begin
writeln(’n=’);
readln(n);
premier(n);
if bool=true then
writeln(‘n,n”est pas un nombre premier’)
else writeln(n,’est un nombre premier’) ;
end.
Program ex05 ;
Var
Bool :boolean ;
N:integer;
Function premier(var a:integer;test:boolean):boolean;
Var
I:integer;
Begin
Test:=false;
I:=2;
Repeat
If(a mod i)=0 then
Test:=true
Else
I:=i+1;
Until (test=true)or(i>(a mod i));
Premier:=test;
End;
Begin
Writeln(‘n=’);
Readln(n);
Bool:=premier(n,bool);
If bool=true then
Writeln(n,’n”est un nombre premier’)
Else writeln(n,’est un nombre premier’) ;
End.
Program ex06 ;
Type
Tab=array[1..3]of real;
Var
I:integer;
Tab1:tab;
Resultat:real;
C:integer;
Function norme(var tab2:tab):real;
Var
I:integer;
Norm:real;
C:integer;
Begin
Norm:=0;
For i:=0 to 2 do
Norm:=norm+sqr(tab2[i]);
Norm:=sqrt(norm);
Norme:=norm;
End;
Begin
For i:=0 to 2 do
Begin
Write(‘tab[‘,i,’]=?’);readln(tab[i]);
End;
Resultat:=norme(tab1);
Writeln(‘la norme est:’,resultat) ;

End.
Program ex07 ;
Type
Tab=array[1..3]of real;
Var
I:=integer;
Tab1:tab;
Resultat:real;
Procedure norme(var tab2:tab);
Var
I:=integer;
Norm:real;
Begin
For i:=0 to 2 do
Norm:=norm+sqr(tab2[i]);
Resultat:=sqr(norm);
End;
Begin
For i:=0 to 2 do
Begin
Write(‘tab[‘,i,’]=?’);
Readln(tab[i]);
End;
Norme(tab1);
Writeln(‘la norme est:’,resultat :7 :3) ;
End.
Program ex08 ;
Type
Tab=array[1..3]of real;
Var
I:=integer;
Tab_l,tab_c:tab;
Resultat:real;
Function prod_vect(var tab1,tab2:tab):real;
Var
I:=integer;
Prod:real;
Begin
Prod:=0;
For i:=0 to 2 do
Prod:=prod+tab1[i]*tab2[i];
Prod_vect:=prod;
End;
Begin
Writeln(‘veuillez saisir les elements de vecteur ligne’) ;
For i :=0 to 2 do
Begin
Write(‘tab_l[‘,i,’]=?);
Readln(tab_l[i];
End;
Writeln(‘veuillez saisir les elements de vecteur colonne’) ;
For i :=0 to 2 do
Begin
Write(‘tab_c[‘,i,’]=?’);
Readln(tab_c[i]);
End;
Resultat:=prod_vect(tab_l,tab_c);
Writeln(‘la norme est:’resultat :7 :3) ;
End.