Fonctions

Qu'est-ce qu'une fonction ?

On peut comparer une fonction à une machine-outil dans un atelier :
on lui donne un nom (ex. « machine à calculer »), on lui fournit éventuellement une ou plusieurs données d'entrée, et elle renvoie un résultat.

Exemple

Bonjour !

Cet algorithme définit une fonction Bonjour qui affiche un message. Elle est ensuite appelée deux fois depuis le programme principal. Plutôt que de recopier les mêmes instructions, on les regroupe dans une seule fonction réutilisable.

Déclaration et appel de fonction

La structure générale d'une fonction est la suivante :

et pour l'appeler :

nom()

L'intérêt est de factoriser le code : si une action se répète plusieurs fois, il suffit de l'écrire une seule fois dans une fonction, puis de l'appeler à chaque besoin.

Exemple

----------

Ce qui s'affiche :

----------
Bienvenue
----------

Les deux traits encadrent le texte, et c'est tout l'intérêt de l'exemple : la même instruction sert deux fois, à deux endroits, sans être recopiée. Changer la longueur du trait se fait alors à un seul endroit.

Les fonctions permettent donc de rendre un algorithme plus lisible, plus organisé, et plus facile à maintenir.

Paramètres et arguments

Autrement dit, les paramètres servent de ponts entre le programme principal et la fonction.

Exemple

Bonjour Alice !

Ici, la fonction Bonjour reçoit un paramètre nom. Quand on appelle Bonjour("Alice"), la variable nom prend temporairement la valeur "Alice". La fonction devient donc un modèle générique que l'on peut réutiliser avec différentes valeurs.

L'appel Somme(4, 7) affichera alors Résultat : 11.

Valeur de retour

Pour renvoyer une valeur, on utilise l'instruction Retourner.

Exemple

La fonction Carré calcule le carré du nombre reçu et renvoie le résultat au programme principal.
L'intérêt est que la fonction ne se contente plus d'agir, elle produit un résultat réutilisable.

C'est un principe fondamental : un bon programme est composé de fonctions qui effectuent des tâches précises et renvoient des résultats clairs.

Ce qui se passe pendant un appel

Le mot « temporairement », employé plus haut, cache la moitié du chapitre. Voici l'enchaînement exact, sur resultat ← Carré(5).

1. Le programme principal s'interrompt sur cette ligne. Il ne continue pas en parallèle : il attend.
2. Le paramètre x de la fonction est créé et reçoit la valeur 5.
3. Le corps de la fonction s'exécute, et lui seul.
4. Retourner x * x calcule 25, sort immédiatement de la fonction, et rend cette valeur.
5. Le paramètre x cesse d'exister.
6. Le programme principal reprend là où il s'était arrêté, Carré(5) ayant été remplacé par 25.

Les six étapes ci-dessus se suivent ici une par une. La colonne x n'existe que pendant l'appel et disparaît au retour : c'est la portée, que le chapitre décrit ensuite, et elle se voit avant de se définir.

La portée : ce qu'une fonction voit et ne voit pas

C'est le point qui surprend le plus, et il découle de l'étape 5 ci-dessus.

Les deux dernières lignes échouent, et c'est voulu. x et resultat appartiennent à la fonction ; le programme principal ne les a jamais vues. La seule chose qui ressort d'une fonction est ce qu'elle retourne.

Vérification

Exercices type

Écrivons chaque fonction, puis son appel : une fonction qu'on n'appelle jamais ne sert à rien.

Exercice 1 : écrire une fonction Double(x) qui renvoie le double d'un nombre, et l'appeler pour x = 8.

Exercice 2 : écrire une fonction Moyenne(a, b) qui renvoie la moyenne de deux nombres, et la tester avec 10 et 16.

Exercice 3 : écrire une fonction EstPair(n) qui renvoie Vrai si le nombre est pair, Faux sinon.

La méthode

1. Nommer la fonction par ce qu'elle rend, pas par ce qu'elle fait de compliqué. Un nom qui demande une explication signale un découpage à revoir.
2. Lister ce qui entre et ce qui sort. Les paramètres sont les entrées, la valeur retournée est la sortie. Tout le reste est du travail interne.
3. Retourner plutôt qu'afficher. Une fonction qui écrit à l'écran ne sert qu'une fois ; une fonction qui retourne se réutilise partout.
4. Se rappeler que l'appel se lit comme une valeur. Une fois la fonction terminée, son appel occupe la place d'un nombre ou d'un texte.
5. Vérifier la portée. Les variables d'une fonction disparaissent à sa sortie, et deux variables de même nom dans deux endroits différents ne sont pas la même.
6. Tester la fonction seule, sur trois valeurs, avant de l'employer dans un algorithme plus grand.

Synthèse

• Une fonction est un bloc d'instructions réutilisable, désigné par un nom.
• Les paramètres lui transmettent des données ; la valeur de Retourner en ressort.
• Afficher n'est pas retourner : Écrire montre à l'utilisateur, Retourner rend une valeur au programme.
• Une fonction qui renvoie un booléen s'emploie directement comme condition.
• Les variables d'une fonction sont locales : elles naissent à l'appel et disparaissent au retour.
• Une fonction ne communique que par deux portes : les paramètres à l'entrée, Retourner à la sortie.