IV. Fonctions

Une fonction est une procédure qui renvoie un résultat, de manière à ce qu’on puisse l’appeler dans une expression.

Exemple

y := cos(x) + 1;
c := chr(x + ord(’0’));

1.Fonction sans paramètre

Principe

Syntaxe

FUNCTION nom_fonction : type_resultat;
BEGIN
    {  ... corps de la fonction ... }
    {  Résultat de la fonction, du type type_resultat }
nom_fonction := expression; 
END;

 

La nouveauté par rapport à une procédure est que l’on « sort » le résultat de la fonction nom_fonction en écrivant une affectation sur son nom.

Attention
nom_fonction n’est pas une variable, et à l’intérieur de la fonction il ne faut surtout pas l’utiliser dans une expression, car cela provoquerait un appel récursif.

• Une fonction doit toujours avoir un résultat ( on ne peut pas le laisser indéterminé).

Appel

PROGRAM ex1;
Uses Wincrt,
VAR x : type_resultat;
{ ici déclaration de la fonction }
BEGIN
   { appel fonction et stockage du résultat dans x }
   x := nom_fonction;
END.

Variables locales

FUNCTION nom_fonction : type_resultat;
VAR locales : types_locales;
BEGIN
    { ... }
    nom_fonction := expression; { du type type_resultat } 
END;


Bonne habitude
Passer par une variable locale res : on fait ce qu’on veut de res dans la fonction, et à la fin de la fonction on ́ecrit nom_fonction := res;

FUNCTION nom_fonction : type_resultat;
VAR res : type_resultat;
BEGIN
    { ... dans le corps, on fait ce qu’on veut de res ... }
    { on dit que le re ́sultat est res }
    nom_fonction := res; 
END;

 

2.Fonction avec paramètres

Syntaxe

FUNCTION nom_fonction ( parametres : types_params ) : type_resultat;
VAR locales : types_locales;
     res : type_resultat;
BEGIN
       { ... }
       nom_fonction := res; 
END;

 

Tout ce que l’on a dit sur le paramètrage des procédures reste valable pour les fonctions.

Procédure ou fonction ?????

Exemple du produit.

PROGRAM exemple5ter;
Uses Wincrt;
  VAR a, b, c, d : real;
PROCEDURE Produit (x, y : real;         |  FUNCTION Produit (x, y : real) : real;
                  var z : real);        |  VAR res : real;
BEGIN                                   |  BEGIN
    z:=x*y;                             |      res := x * y;
END;                                    |  END;
                                     BEGIN
                                        write (’Donner les valeurs de a et b’); readln (a, b);
Produit (a, b, c);                      | c := Produit (a, b);
Produit (a-1, b+1, d);                  | d := Produit (a-1, b+1);
writeln (’c = ’, c, ’ d = ’, d);
                                     END.



Passage de types enregistrement

Exemple On veut savoir si un couple d’amis est assorti. On fixe les règles suivantes : le couple est assorti si ils ont moins de 10 ans d’écart, ou si le mari est agé et riche.

PROGRAM Assorti;
Uses Wincrt;    
TYPE
       humain_t =Record
            age, taille : integer;
            riche       : boolean; 
            End;
      
       couple_t = Record
            homme, femme : humain_t;
            nb_enfant    : integer;
FUNCTION difference_age (h, f : humain_t) : integer;
VAR res : integer;
BEGIN
res := abs (h.age - f.age);
difference_age := res; 
END;

FUNCTION couple_assorti (c : couple_t) : boolean; 
VAR res : boolean;
BEGIN
     res := false;
     if difference_age (c.homme, c.femme) < 10 then res := true;
     if (c.homme.age > 75) and (c.homme.riche) then res := true;
     couple_assorti := res;
END;

VAR amis : couple_t; 
BEGIN
    { ... }
    write (’Ce couple avec ’, amis.nb_enfant, ’ enfant(s) est ’);
    if couple_assorti (amis) then writeln (’assorti.’)
    else writeln (’non assorti.’);
END.

 

3.Fonction avec plusieurs résultats

Il est fréquent que l’on écrive une fonction qui renvoie un booléen qui dit si tout s’est bien passé, tandis que les vrais résultats sont passés dans les paramètres.

Exemple Une fonction qui prend une lettre, la met en majuscule ou renvoie une erreur si le caractère n’est pas une lettre.

FUNCTION maj_lettre ( lettre : char; 
                      var maj : char ) : boolean;
VAR res : boolean;
BEGIN
    { init }
    maj := lettre;
    res := true; { pas d’erreur }
 case lettre of 
   ’a’ .. ’z’ : maj := chr(ord(lettre) - ord(’a’) + ord(’A’)); 
   ’A’ .. ’Z’, ’_’ : ; { rien }
   else res := false;
 end; { case lettre fini }
 
maj_lettre := res;
END;

L’appel de cette fonction :

VAR c, m : char;
BEGIN
    readln (c);
    if maj_lettre (c,m) then
    writeln (’La majuscule de ’, c, ’ est ’, m)
    else writeln (’Le caractère ’, c, ’ n’’est pas une lettre’);
END.

4.Gestion d’erreurs

On veut généraliser l’usage de fonctions renvoyant un code d’erreur, et dont les résultats sont passés en paramètres.

– Soient F1, F2, etc, de telles fonctions renvoyant un booléen.

– Soit ok un booléen.

– Soient I1, I2, etc, des instructions.

Considérons la séquence d’instruction suivante

I1;
ok := F1 ( ... );
I2;
ok := F2 ( ... ); 
I3;
ok := F3 ( ... ); 
I4;
{ ... }

On veut exécuter ce traitement, mais l’interrompre dÈs qu’il y a une erreur. On devrait normalement écrire :

I1;
if F1 ( ... ) then 
   begin
       I2;
       if F2 ( ... ) then
          begin
          I3;
          if F3 ( ... ) then
             begin
             I4;
             { ... }
             end;
          end;
    end;

C’est lourd, on se perd rapidement dans tous ces begin end. Il est beaucoup simple d’écrire

I1;
ok := F1 ( ... );
if ok then
begin
  I2;
  ok := F2 ( ... );
end;
if ok then
begin
  I3;
  ok := F3 ( ... );
end;
if ok then
begin
  I4;
  { ... } 
end;

Dès que ok est faux, plus aucun bloc suivant n’est exécuté.

Facebook