Les fonctions et leurs paramètres

Les chapitres précédents écrivaient chaque algorithme d'un seul bloc, du début à la fin. Le chapitre sur les tableaux a pourtant déjà employé une fonction, sans s'y attarder : longueur, qui reçoit un tableau et rend son nombre de cases. Ce chapitre montre comment écrire les siennes, et surtout ce qui se passe exactement quand on les appelle : ce qui entre, ce qui sort, et ce que la fonction ne voit pas.

Qu'est-ce qu'une fonction ?

On peut comparer une fonction à une machine-outil dans un atelier : elle porte un nom, on lui fournit éventuellement des pièces à l'entrée, et elle produit un résultat, ou se contente d'effectuer une opération.

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

Écrire une fonction, puis l'appeler

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

et pour l'appeler :

nom()

Fonction ouvre la définition, FinFonction la ferme, et les parenthèses qui suivent le nom recevront plus loin les paramètres. Définir une fonction n'exécute rien : son corps ne s'exécute qu'au moment où une ligne l'appelle, par son nom suivi de parenthèses. Dans un algorithme complet, les fonctions s'écrivent en premier, avant le Début ; le programme principal, entre Début et Fin, vient ensuite et les appelle.

L'intérêt est de factoriser le code : une action qui se répète s'écrit une seule fois, dans une fonction, puis s'appelle à chaque besoin.

Ce qui s'affiche :

----------
Rapport de production
----------

Les deux traits encadrent le titre, 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.

Paramètres et arguments

Quand on appelle Bonjour("Alice"), le paramètre nom est créé et reçoit une copie de l'argument : c'est le passage par valeur. La fonction travaille sur cette copie le temps de l'appel, et l'appelant garde sa propre valeur ; un tableau passé en argument est copié de la même façon, case par case. La section sur la portée montre ce que cette copie protège. La fonction devient ainsi un modèle, que l'on réutilise avec des valeurs différentes.

Une fonction peut recevoir plusieurs paramètres, séparés par des virgules ; les arguments leur sont attribués dans l'ordre, le premier au premier, le deuxième au deuxième. La section suivante en donne un exemple.

Valeur de retour

La fonction Carré calcule le carré du nombre reçu et le rend au programme principal, qui le range dans resultat. Elle ne se contente plus d'agir : elle produit un résultat réutilisable.

Une fonction qui ne retourne rien, comme Bonjour ou Ligne, se contente d'agir ; certains cours l'appellent une procédure. Son appel s'écrit seul sur sa ligne, et ne peut pas servir de valeur : x ← Ligne() arrête l'algorithme, faute de valeur à ranger.

Avec plusieurs paramètres, le principe ne change pas. Cette fonction calcule un prix soldé, à partir du prix et du taux de remise en pourcentage :

Deux paramètres, et deux arguments attribués dans l'ordre : au premier appel, 80 va au prix et 25 au taux, soit 60 euros. Parce que la fonction retourne son résultat au lieu de l'afficher, l'appelant en fait ce qu'il veut : ici l'écrire, ailleurs l'ajouter à des frais de port ou le comparer à un budget. C'est la règle à retenir : une bonne fonction effectue une tâche précise et rend un résultat clair.

Ce qui se passe pendant un appel

Un appel interrompt le programme principal, crée les paramètres, exécute le corps de la fonction, puis rend la main. 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 une copie de 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.

L'encadré de Carré n'existe que pendant l'appel : c'est la portée, que le chapitre décrit plus bas, et elle se voit avant de se définir.

La ligne d'appel se lit comme une valeur. Une fois la fonction terminée, Carré(5) ne se lit plus comme un appel mais comme le nombre 25. C'est pourquoi on peut écrire resultat ← Carré(5) + 1, ou passer l'appel directement à Écrire. Une fonction qui retourne une valeur s'emploie partout où l'on écrirait cette valeur.

L'inverse est une erreur silencieuse : Carré(5), écrit seul sur une ligne, calcule 25 et le jette. Une valeur retournée qu'on ne range nulle part est perdue.

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.

Ce que le programme principal ne voit pas

L'avant-dernière ligne échoue, et c'est voulu ; la dernière échouerait de la même façon, mais l'algorithme s'est arrêté avant. 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.

Ce que la fonction ne voit pas

La frontière vaut dans les deux directions : une fonction ne voit pas davantage les variables du programme principal. Tout ce dont elle a besoin doit lui arriver par un paramètre.

La figure s'arrête sur la ligne 2 : seuil existe bien, et l'encadré du programme principal le montre, mais la fonction n'y a pas accès. La correction fait entrer le seuil par la porte prévue, un second paramètre :

La figure corrigée affiche Vrai : 95 dépasse le seuil de 80. Le paramètre porte le même nom que la variable du programme principal, mais ce sont deux variables distinctes ; l'encadré marqué EnAlerte montre la copie que la fonction a reçue.

Mettre en pratique

Un appel se lit comme la valeur qu'il rend. Chaque question se résout en remplaçant les appels par leurs valeurs, du plus intérieur au plus extérieur, sans perdre de vue qu'un paramètre reçoit une copie.

Chaque exercice demande la fonction et son appel : une fonction qu'on n'appelle jamais ne sert à rien.