Définir des fonctions avec paramètres

1. Pourquoi avons-nous besoin de fonctions ?

Imaginez que vous écriviez un algorithme et que vous deviez effectuer la même tâche plusieurs fois à différents endroits. Par exemple, calculer la factorielle d'un nombre. Sans une méthode pour regrouper ce code, vous seriez obligé de le copier-coller, ce qui rend votre algorithme long, répétitif et difficile à maintenir.

La solution à ce problème est le sous-programme, que nous appellerons plus couramment fonction ou procédure. L'idée est simple : écrire le code pour une tâche une seule fois, lui donner un nom, et ensuite appeler ce nom chaque fois que vous en avez besoin.

Utiliser des fonctions apporte trois avantages majeurs, directement liés à l'écriture de "code clean" :

• Réutilisabilité : Vous écrivez le code une fois et vous l'utilisez autant de fois que vous le souhaitez. Si vous devez corriger ou améliorer cette tâche, vous ne le faites qu'à un seul endroit.
• Lisibilité : Le corps principal de votre algorithme devient beaucoup plus court et plus facile à comprendre. Au lieu d'un long bloc de calcul, vous aurez simplement une ligne comme factorielleN ← CalculerFactorielle(n). Le nom de la fonction décrit ce qu'elle fait.
• Modularité : C'est l'art de décomposer un gros problème complexe en une série de petits sous-problèmes plus simples à résoudre. Chaque fonction résout un de ces sous-problèmes.

2. La fonction comme "boîte noire"

La meilleure façon de se représenter une fonction est de la voir comme une "boîte noire". Vous ne vous souciez pas de comment elle fonctionne à l'intérieur, mais vous savez ce qu'elle fait, ce dont elle a besoin pour le faire et ce qu'elle vous donne en retour.

Cette boîte noire interagit avec le reste de l'algorithme uniquement via des points d'entrée et de sortie bien définis :

• Les entrées (Paramètres) : Ce sont les données que vous fournissez à la fonction pour qu'elle puisse travailler. Par exemple, pour une fonction CalculerSomme, les paramètres seraient les deux nombres à additionner.
• Le traitement (Corps de la fonction) : C'est l'ensemble des instructions (calculs, boucles, conditions) qui sont "cachées" à l'intérieur de la boîte.
• La sortie (Valeur de retour) : C'est le résultat que la fonction produit et renvoie à l'algorithme principal. Une fonction CalculerSomme retournerait le résultat de l'addition.

L'image mentionne aussi de ne pas utiliser d'objets "globaux". C'est un conseil très important : une fonction "propre" ne doit interagir avec l'extérieur que via ses paramètres et sa valeur de retour. Cela la rend autonome et prévisible.

3. Définir des procédures et des fonctions

En algorithmique, on distingue souvent deux types de "boîtes noires" :

• Une procédure exécute une action (ex: afficher un message à l'écran) mais ne renvoie aucune valeur.
• Une fonction effectue un calcul et renvoie une valeur en résultat.

Pour bien comprendre comment les définir, étudions quelques exemples.

Analysons ensemble ce que vous venez de lire.

La procédure : exécuter une tâche

Une procédure est utilisée quand on veut effectuer une action sans attendre de résultat en retour.

Syntaxe de base :

Procédure NomDeLaProcédure(paramètre1: type, paramètre2: type, ...)
Début
  // Instructions à exécuter
FinProcédure

• Exemple 1 (sans paramètre) : Une tâche qui ne nécessite aucune information extérieure.

  Procédure afficherHello()
  Début
    Ecrire("Hello, World!")
  FinProcédure
  

• Exemple 2 (avec un paramètre) : La procédure reçoit une information (str) pour l'utiliser dans sa tâche.

  Procédure afficherMsg(str: chaine de caractères)
  Début
    Ecrire(str)
  FinProcédure
  

La fonction : calculer et retourner une valeur

Une fonction est utilisée lorsqu'on a besoin d'obtenir un résultat après un calcul.

Syntaxe de base :

Fonction NomDeLaFonction(paramètre1: type, ...): TypeDeRetour
Début
  // Instructions
  retourner valeur_de_retour
FinFonction

Notez les deux différences majeures :

1. On spécifie le type de la valeur de retour dans la déclaration (: TypeDeRetour).
2. On utilise l'instruction retourner pour renvoyer le résultat final.

• Exemple 3 (calcul simple) : La fonction prend deux entiers et retourne leur somme, qui est aussi un entier.

  // Note: L'exemple de la ressource omet le type de retour, je l'ajoute pour plus de clarté.
  Fonction somme(n1:entier, n2:entier): entier
  Début
    retourner n1 + n2
  FinFonction
  

4. La structure formelle d'une définition

Maintenant que vous avez vu des exemples concrets, formalisons la structure complète de la définition d'une fonction. Un langage de pseudo-code plus formel, comme EXALGO, la décrit ainsi.

Voici les éléments clés de cette syntaxe :

1. L'en-tête (ou signature) : C'est la première ligne, qui définit le "contrat" de la fonction.
   fonction NomDeFonction (ListeParamètres) :TypeRésultat;

   • NomDeFonction : Un nom descriptif pour la tâche.
   • ListeParamètres : Les "entrées" de la boîte noire, avec leur nom et leur type (ex: val n :entier).
   • TypeRésultat : Le type de la "sortie" (entier, réel, booléen...). Pour une procédure, on utilise souvent le mot-clé vide.

2. Le corps : Le bloc d'instructions entre début et fin. C'est la logique interne de la boîte noire. C'est aussi ici que l'on peut déclarer des variables qui n'existeront qu'à l'intérieur de la fonction (on les appelle des variables locales).

5. À vous de jouer !

Mettons cela en pratique. Votre objectif est d'écrire, sur papier ou dans un éditeur de texte, la définition complète d'une procédure.

Problème : Écrire une procédure AfficherRectangle qui prend trois paramètres : largeur (entier), hauteur (entier) et symbole (caractère). Cette procédure doit dessiner à l'écran un rectangle plein en utilisant le symbole donné.

Par exemple, si on l'utilisait avec les valeurs largeur=5, hauteur=3 et symbole='*', le résultat affiché devrait être :

*****
*****
*****

Indice : Vous aurez besoin de boucles imbriquées, un concept que nous avons vu dans le module 3.

Procédure AfficherRectangle(largeur: entier, hauteur: entier, symbole: caractère)
Variables
  i, j: entier // Variables locales pour les boucles

Début
  // Boucle pour chaque ligne (hauteur)
  Pour i allant de 1 à hauteur Faire
    // Pour chaque ligne, on affiche 'largeur' fois le symbole
    Pour j allant de 1 à largeur Faire
      EcrireSansRetourALaLigne(symbole) // Affiche le symbole sans passer à la ligne
    FinPour
    Ecrire("") // Passe à la ligne suivante après avoir fini une ligne de symboles
  FinPour
FinProcédure

Conclusion

Félicitations ! Vous venez de franchir une étape majeure. Vous savez maintenant comment encapsuler une tâche dans un bloc de code réutilisable. C'est la première brique de la modularité, une compétence indispensable pour concevoir des algorithmes complexes de manière organisée et, finalement, pour écrire du code "propre".

Les points clés à retenir :

• Les fonctions et procédures sont des blocs de code nommés qui accomplissent une tâche spécifique.
• Elles favorisent la réutilisabilité, la lisibilité et la modularité.
• Les paramètres sont les données d'entrée d'une fonction.
• Une procédure exécute une action ; une fonction calcule et retourne une valeur via l'instruction retourner.
• Définir une fonction consiste à écrire sa signature (nom, paramètres, type de retour) et son corps (les instructions).

Et après ?

Nous avons appris à construire nos "boîtes noires". Mais comment les faire fonctionner ? Dans la prochaine leçon, nous verrons comment appeler une fonction depuis notre algorithme principal et, surtout, comment récupérer et utiliser la valeur qu'elle nous retourne.