Appeler une fonction et utiliser sa valeur de retour

1. Qu'est-ce qu'un "appel" de fonction ?

Dans la leçon précédente, nous avons défini une fonction somme :

Fonction somme(n1: entier, n2: entier): entier
Début
  retourner n1 + n2
FinFonction

Cette définition existe comme un plan, une recette disponible. Pour l'utiliser, notre algorithme principal doit l'appeler. Un appel de fonction est une instruction qui :

1. Met en pause l'exécution de l'algorithme principal.
2. Passe les valeurs nécessaires (les arguments) à la fonction.
3. Exécute le code à l'intérieur de la fonction.
4. Récupère la valeur renvoyée par l'instruction retourner.
5. Reprend l'exécution de l'algorithme principal là où il s'était arrêté, avec le résultat en main.

La syntaxe pour appeler une fonction et stocker son résultat est simple et intuitive :
variable_de_destination ← NomDeLaFonction(argument1, argument2, ...)

Par exemple, pour utiliser notre fonction somme :

Algorithme Principal
Variables
  total: entier
Début
  total ← somme(10, 5) // Appel de la fonction
  Ecrire("Le résultat est : ", total) // Affichera "Le résultat est : 15"
Fin

Ici, les valeurs 10 et 5 sont les arguments. La valeur 15, retournée par la fonction, est stockée dans la variable total.

2. Récupérer et utiliser la valeur de retour

La valeur retournée par une fonction est sa raison d'être. C'est le résultat de son travail. L'algorithme qui l'appelle peut alors faire ce qu'il veut avec ce résultat.

Pour approfondir ce mécanisme, nous allons analyser un exemple concret.

Ce que vous venez de lire est au cœur de l'écriture de code propre. Au lieu d'avoir un algorithme principal encombré de détails techniques (la boucle de contrôle de saisie), nous avons un code clair et direct :
Ecrire "Etes-vous marié?"
Rep1 ← RepOuiNon()

L'algorithme principal se concentre sur le "quoi" (poser une question et obtenir une réponse), tandis que la fonction RepOuiNon se charge du "comment" (la logique pour s'assurer que la réponse est bien "Oui" ou "Non").

Visualisons ce flux de données avec un schéma.

3. L'indépendance des variables

Un point très important, que nous explorerons plus en détail dans la prochaine leçon, est que les variables utilisées à l'intérieur d'une fonction sont distinctes de celles de l'algorithme principal.

Retenez cette idée clé : la fonction LireTableau travaille avec une variable interne nommée A. Lorsqu'elle a fini, elle renvoie le contenu de A. L'algorithme principal récupère ce contenu et le stocke dans sa propre variable, qu'il a choisi de nommer T. C'est ce qui rend les fonctions si modulaires et réutilisables : elles n'ont pas besoin de connaître les noms des variables de l'algorithme qui les utilise.

4. Utilisation directe de la valeur de retour

Il n'est pas toujours nécessaire de stocker la valeur de retour dans une variable intermédiaire. On peut l'utiliser directement dans une expression ou comme argument pour une autre fonction. C'est une technique qui rend le code encore plus concis.

Exemple 1 : Dans une expression de calcul

Imaginez une fonction CalculerTVA(prixHT: réel): réel. Au lieu d'écrire :

montantTVA ← CalculerTVA(100.0)
prixTTC ← 100.0 + montantTVA

Vous pouvez écrire directement :

prixTTC ← 100.0 + CalculerTVA(100.0)

Le résultat de CalculerTVA(100.0) est utilisé immédiatement dans l'addition.

Exemple 2 : Comme argument pour une autre fonction

Supposons que nous ayons une fonction AfficherPrix(prix: réel). Nous pouvons combiner les appels :

// Appel imbriqué : le résultat de somme() sert d'argument à CalculerTVA()
// dont le résultat sert lui-même d'argument à AfficherPrix()
AfficherPrix( CalculerTVA( somme(50.0, 50.0) ) )

Bien que cela soit puissant, utilisez cette technique avec modération. Si une ligne devient trop complexe, il est préférable de la décomposer avec des variables intermédiaires pour garantir la lisibilité.

5. À vous de jouer !

Mettons tout cela en pratique. Nous allons créer un petit algorithme qui utilise une fonction de calcul.

Problème :

1. Écrivez la définition d'une fonction CalculerCarre(nombre: entier): entier qui prend un nombre en paramètre et retourne son carré (c'est-à-dire nombre * nombre).
2. Écrivez un algorithme principal qui :
   a. Demande à l'utilisateur de saisir un nombre.
   b. Appelle la fonction CalculerCarre avec ce nombre.
   c. Stocke le résultat dans une variable.
   d. Affiche un message clair, par exemple : "Le carré de 5 est 25."

Prenez quelques minutes pour écrire votre solution sur papier ou dans un éditeur de texte.

Fonction CalculerCarre(nombre: entier): entier
Variables
  resultat: entier
Début
  resultat ← nombre * nombre
  retourner resultat
FinFonction

Algorithme Principal
Variables
  num_utilisateur: entier
  carre_resultat: entier
Début
  Ecrire("Veuillez saisir un nombre entier :")
  Lire(num_utilisateur)

  // Appel de la fonction et stockage du retour
  carre_resultat ← CalculerCarre(num_utilisateur)

  Ecrire("Le carré de ", num_utilisateur, " est ", carre_resultat)
Fin

Conclusion

Félicitations ! Vous maîtrisez désormais le cycle complet de la modularité : définir une fonction ET l'appeler pour en exploiter le résultat. C'est un pas de géant vers l'écriture d'algorithmes clairs, organisés et faciles à maintenir.

Les points clés à retenir :

• On appelle une fonction avec son nom et des arguments entre parenthèses : NomFonction(arg1, arg2).
• Le résultat d'une fonction est récupéré via une assignation : variable ← NomFonction(...).
• La variable qui reçoit le résultat doit être d'un type compatible avec le type de retour de la fonction.
• Les variables à l'intérieur et à l'extérieur de la fonction sont indépendantes.
• L'appel de fonction permet de remplacer des blocs de code complexes par une seule ligne expressive, rendant l'algorithme principal beaucoup plus lisible.

Et après ?

Nous avons effleuré l'idée que les variables à l'intérieur d'une fonction sont "privées". Dans la prochaine leçon, nous allons formaliser ce concept en étudiant la portée des variables. Nous distinguerons les variables locales (qui n'existent qu'à l'intérieur d'une fonction) des variables globales, et nous verrons pourquoi il est essentiel de bien gérer cette distinction pour éviter des erreurs subtiles.