CHAPITRE 9 : LES FONCTIONS ET LES PROCEDURES

Lorsqu'un meme traitement revient plusieurs fois, il ne faut pas le reecrire. Les sous-programmes, fonctions et procedures, permettent de l'ecrire une fois et de l'utiliser partout.

1. Pourquoi ?

• Eviter les repetitions
• Rendre le programme plus lisible
• Faciliter la maintenance
• Simplifier les tests

2. La fonction

Une fonction recoit eventuellement des parametres, effectue un traitement et retourne une valeur.

Entrees  ──▶  Fonction  ──▶  Valeur retournee

Fonction Nom(parametres) : TypeRetour;

Var
    variables_locales;

Debut

    ...
    Retourner(valeur);

Fin

Quelques exemples

Fonction Carre(x : entier) : entier;
Debut
    Retourner(x * x);
Fin

Fonction ValeurAbsolue(x : reel) : reel;
Debut
    Si(x < 0) Alors
        Retourner(-x);
    Sinon
        Retourner(x);
    FinSi
Fin

Fonction Maximum(a, b : entier) : entier;
Debut
    Si(a > b) Alors
        Retourner(a);
    Sinon
        Retourner(b);
    FinSi
Fin

La factorielle

Fonction Factorielle(n : entier) : entier;

Var
    i, f : entier;

Debut

    f <- 1;

    Pour i de 1 a n Faire
        f <- f * i;
    FinPour

    Retourner(f);

Fin

3. Appeler une fonction

x       <- Factorielle(5);
surface <- PI * Carre(r);
Ecrire(Maximum(a, b));

Une fonction s'utilise partout ou une valeur est attendue.

4. La procedure

Une procedure execute un traitement sans retourner de valeur.

Procedure Nom(parametres);

Var
    ...

Debut
    ...
Fin

Procedure AfficherSomme(a, b : entier);
Debut
    Ecrire(a + b);
Fin

// Appel
AfficherSomme(5, 8);   // affiche 13

5. Fonction ou procedure ?

6. Parametres formels et effectifs

7. Passage par valeur

Une copie est transmise : la variable d'origine n'est pas modifiee.

Procedure Test(x : entier);
Debut
    x <- 100;
Fin

// Programme principal
a <- 5;
Test(a);
Ecrire(a);     // affiche 5, pas 100

8. Passage par variable

Avec le mot-cle Var, c'est la variable elle-meme qui est transmise.

Procedure Permuter(Var a, b : entier);

Var
    temp : entier;

Debut

    temp <- a;
    a    <- b;
    b    <- temp;

Fin

// Appel
Permuter(x, y);   // x et y sont reellement echanges

C'est la difference essentielle : sans Var, la permutation n'aurait aucun effet sur x et y.

9. Variables locales et globales

• Une variable locale est declaree dans un sous-programme. Elle n'existe que pendant son execution.
• Une variable globale est declaree dans l'algorithme principal.

Une variable locale masque une globale de meme nom. Mieux vaut eviter cette situation : elle nuit a la lisibilite et provoque des erreurs difficiles a reperer.

10. Les erreurs frequentes

• Oublier Retourner dans une fonction
• Utiliser Retourner dans une procedure
• Modifier un parametre passe par valeur en croyant modifier l'original
• Declarer deux fois la meme variable avec des significations differentes

A retenir

• Une fonction retourne une valeur avec Retourner
• Une procedure realise un traitement sans rien retourner
• Passage par valeur : une copie. Passage par Var : la variable d'origine
• Une fonction ne devrait faire qu'une seule chose