Compléments sur les fonctions

Date de publication : 16/03/2002 , Date de mise à jour : 27/01/2007

Les fonctions sont des sous-programmes autonomes et spécialisés qui présentent l'intérêt de pouvoir réutiliser du code.

Ce tutoriel parfairera vos connaissances avec la modification des paramètres d'une fonction et leur appel.

1. Paramètres modifiables
1.1. Exemple 1
1.2. Exemple 2
1.3. Exemple 3
2. Appels de fonction
2.1. Exemple 1
2.2. Exemple 2

1. Paramètres modifiables

L'entête d'une fonction spécifie son nom, le type de son résultat, et les paramètres (avec leurs types). Ces paramètres sont considérés comme les données transmises à la fonction, c'est à dire l'entrée de la fonction. Il peut arriver que la fonction modifie ces paramètres lors de l'exécution de son algorithme. On parle alors de paramètre modifiable : il s'agit à la fois d'une entrée et d'une sortie de l'algorithme. La déclaration d'un tel paramètre dans la liste des paramètres se fait de la manière suivante :

fonction nom(nom_param InOut : type_param):type_résultat

1.1. Exemple 1

La fonction suivante prend deux paramètres réels et les modifie de manière à ce qu'ils soient dans l'ordre croissant (N.B. : elle ne retourne pas de résultat) :

fonction ordonner2Réels(x InOut : réel, y InOut : réel)
    début
        si x > y
            alors
                tmp <- x
                x <- y
                y <- temp
        fsi
    fin

Lexique :
    - x : réel, valeur fournie, est modifiée (éventuellement) en le minimum de x et y
    - y : réel, valeur fournie, est modifiée (éventuellement) en le maximum de x et y
    - tmp : réel, variable de stockage temporaire

Il est évidemment possible d'avoir des paramètres modifiables et des paramètres non modifiables dans une même fonction.

1.2. Exemple 2

La fonction suivante prend trois paramètres réels : les deux premiers sont les bornes d'un intervalle, et le troisième est (éventuellement) modifié de manière à rester dans l'intervalle spécifié.

fonction seuillerRéel(inf : réel, sup : réel, x InOut : réel)
    début
        si x < inf
            alors x <- inf
            sinon
                si x > sup
                    alors x <- sup
                fsi
        fsi
    fin

Lexique :
    - inf : réel, borne inférieure de l'intervalle
    - sup : réel, borne supérieure de l'intervalle
    - x : réel, valeur fournie, est modifiée (éventuellement) par seuillage

Enfin, une fonction qui utilise des paramètres modifiables peut également renvoyer un résultat.

1.3. Exemple 3

La fonction suivante est similaire à celle de l'exemple précédent. Elle renvoie en plus un booléen égal à vrai si et seulement si le paramètre x a été effectivement modifié.

fonction modifierRéelParSeuillage(inf : réel, sup : réel, x InOut : réel):booléen
    début
        res <- faux
        si x < inf
            alors
                x <- inf
                res <- vrai
            sinon
                si x > sup
                    alors
                        x <- sup
                        res <- vrai
                fsi
        fsi
        retourne res
    fin

Lexique :
    - inf : réel, borne inférieure de l'intervalle
    - sup : réel, borne supérieure de l'intervalle
    - x : réel, valeur fournie, est modifiée (éventuellement) par seuillage
    - res : booléen, résultat vrai si x est modifié

2. Appels de fonction

Les fonctions ont jusqu'à présent été utilisées de façon à présenter certains algorithmes de manière autonome (données fournies, résultat calculé). Plus généralement, les fonctions sont utilisées pour décrire les différentes étapes d'un algorithme plus complexe. On peut alors appeler ces fonctions pour réaliser les étapes de calcul correspondantes : lors de l'appel, on indique grâce aux paramètres les données sur lesquelles la fonction doit travailler, puis on récupère le résultat retourné. Un appel de fonction provoque donc l'exécution complète du corps de cette fonction.

Le passage des paramètres sera décrit ici de manière intuitive. Chaque langage de programmation traite cet aspect d'une manière rigoureuse, ce qui nécessite d'aborder les notions plus détaillées (paramètres formels et effectifs, passage par valeur ou par adresse, portée des paramètres, compatibilité des types, ...).

2.1. Exemple 1

Décrire un algorithme qui calcule le maximum de 4 réels saisis au clavier. Le calcul du maximum de deux valeurs sera décrit par une fonction.

fonction calculerMax2Réels(x : réel, y : réel):réel
    début
        si x > y         // f1
            alors
                res <- x // f2
            sinon
                res <- y // f3
        fsi
        retourne res     // f4
    fin

Lexique :
    - x : réel
    - y : réel
    - res : réel, maximum trouvé


Algorithme
    début
        maximum <- lire()                                 // 1
        pour i de 2 à 4 faire                             // 2
            nombre <- lire()                              // 3
            maximum <- calculerMax2Réels(nombre, maximum) // 4
        fpour
        écrire(maximum)                                   // 5
    fin

Lexique :
    - maximum : réel, maximum des i premiers nombre réels
    - nombre : réel, ième réel donné
    - i : entier, indice d'itération

Schéma de l'évolution de l'état des variables instruction par instruction :

Il est possible d'utiliser les mêmes variables dans différentes fonctions et dans l'algorithme principal. On précise donc à chaque fois à quelle fonction correspond la variable.

On suppose que les valeurs introduites par l'utilisateur sont : 35, 80, 37, 22.

Variables :	Algorithme principal			fonction calculerMax2Réels
Instructions	maximum	nombre	i	x	y	x > y	res
1	35			/	/	/	/
2			2	/	/	/	/
3		80		/	/	/	/
4				80	35
f1						vrai
f2							80
f4	80						retourne
2			3	/	/	/	/
3		37		/	/	/	/
4				37	80
f1						faux
f3							80
f4	80						retourne
2			4	/	/	/	/
3		22		/	/	/	/
4				22	80
f1						faux
f3							80
f4	80						retourne
2			(fin)	/	/	/	/
5	écrire()			/	/	/	/

Les paramètres fournis lors de l'appel peuvent être des expressions, s'il ne s'agit pas de paramètres modifiables.

Si une fonction a des paramètres modifiables, les paramètres fournis lors de l'appel doivent être des variables. Les instructions d'affectation que contient la fonction appelée peuvent alors modifier ces variables.

Une fonction peut elle-même contenir plusieurs appels de fonctions. Il est également possible d'utiliser le résultat d'une fonction directement dans le paramètre fourni à l'appel d'une autre fonction.

2.2. Exemple 2

Un étudiant doit, pour obtenir son diplôme, passer un écrit et un oral dans deux modules. Le coefficient du premier module est le double de celui du second module. La moyenne d'un module, afin de ne pas pénaliser trop les éventuels échecs accidentels, accorde un coefficient double à la meilleure des deux notes obtenues.
On veut décrire un algorithme où, après saisie des quatre notes, la décision finale est affichée (diplôme obtenu si la moyenne est supérieure ou égale à 10, aucun module ne devant avoir une moyenne inférieure à 8).

fonction calculerMoyenne(n1:réel, n2:réel):réel
    début
        moy <- (n1 + 2*n2)/3
        retourne moy
    fin

Lexique :
    - n1 : réel, note de coefficient 1
    - n2 : réel, note de coefficient 2
    - moy : réel, moyenne calculée


fonction calculerNoteModule(n1:réel, n2:réel):réel
    début
        si n1 > n2
            alors
                note <- calculerMoyenne(n2, n1)
            sinon
                note <- calculerMoyenne(n1, n2)
        fsi
        retourne note
    fin

Lexique :
    - n1 : réel, première note
    - n2 : réel, deuxième note
    - note : réel, note du module


fonction accorderDiplôme(m1:réel, m2:réel):booléen
    début
        moy <- calculerMoyenne(m2, m1)
        si moy < 10
            alors
                recu <- faux
            sinon
                si (m1 < 8) ou (m2 < 8)
                    alors
                        recu <- faux
                    sinon
                        recu <- vrai
                fsi
        fsi
        retourne recu
    fin

Lexique :
    - m1 : réel, moyenne premier module
    - m2 : réel, moyenne second module
    - moy : réel, moyenne générale
    - recu : booléen, à vrai si l'étudiant a obtenu son diplôme


Algorithme
    début
        ne_m1 <- lire()
        no_m1 <- lire()
        ne_m2 <- lire()
        no_m2 <- lire()
        obtenu <- accorderDiplôme(calculerNoteModule(ne_m1, no_m1), calculerNoteModule(ne_m2, no_m2))
        si obtenu
            alors écrire("diplôme obtenu")
            sinon écrire("diplôme non accordé")
        fsi
    fin

Lexique :
    - ne_m1 : réel, note d'écrit du premier module
    - no_m1 : réel, note d'oral du premier module
    - ne_m2 : réel, note d'écrit du second module
    - no_m2 : réel, note d'oral du second module
    - obtenu : booléen, vrai si le diplôme est accordé

Copyright © 2007 . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.