# Fonctions Paramétrées ## Introduction Dans le domaine de l'algorithmique, la conception de solutions pour des problèmes complexes nécessite souvent de décomposer ces problèmes en sous-problèmes plus petits et gérables. Les **fonctions** (également appelées procédures, sous-programmes ou méthodes selon le contexte et le langage) sont des blocs de code autonomes conçus pour accomplir une tâche spécifique. Elles sont fondamentales pour l'organisation, la réutilisabilité et la maintenabilité du code. L'introduction des paramètres permet à ces fonctions d'être génériques et d'opérer sur différentes données sans avoir à réécrire le même code. > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/Sr2n1zUQpFo?si=a-L99bVJ9tNr_W11" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## 1. Les Paramètres de Fonction Les paramètres sont des variables spéciales utilisées pour passer des informations à une fonction. > [!definition] Paramètres Formels et Arguments Réels > - Les **paramètres formels** sont les variables déclarées dans la signature de la fonction. Ils définissent le type et l'ordre des données attendues. > - Les **arguments réels** (ou effectifs) sont les valeurs passées à la fonction lors de son appel. Ces valeurs sont copiées ou référencées par les paramètres formels. > [!example] Exemple de fonction avec paramètres > ```pseudo-code > FONCTION Addition(a: ENTIER, b: ENTIER) : ENTIER > { > RESULTAT = a + b > RETOURNER RESULTAT > } > > // Appel de la fonction > x = 5 > y = 10 > somme = Addition(x, y) // Ici, x et y sont les arguments réels > ECRIRE "La somme est : " + somme // Affiche : La somme est : 15 > ``` ## 2. Types de Passage de Paramètres La manière dont les arguments réels sont associés aux paramètres formels est cruciale et peut varier selon les langages de programmation. Les deux méthodes principales sont le passage par valeur et le passage par référence. ### 2.1. Passage par Valeur > [!definition] Passage par Valeur > Lors du **passage par valeur**, une copie de l'argument réel est faite et assignée au paramètre formel. Toute modification du paramètre à l'intérieur de la fonction n'affecte pas l'argument réel original. ```pseudo-code PROCEDURE IncrementerParValeur(nombre: ENTIER) { nombre = nombre + 1 ECRIRE "Dans la fonction (par valeur) : " + nombre // Ex: 11 } // Appel valeur_originale = 10 IncrementerParValeur(valeur_originale) ECRIRE "Après la fonction (valeur originale) : " + valeur_originale // Ex: 10 (inchangé) ``` > [!note] Remarque > C'est le mode de passage le plus courant et le plus sûr, car il prévient les effets de bord inattendus sur les variables passées. ### 2.2. Passage par Référence > [!definition] Passage par Référence > Lors du **passage par référence**, le paramètre formel ne reçoit pas une copie de la valeur, mais une référence (l'adresse mémoire) de l'argument réel. Toute modification du paramètre à l'intérieur de la fonction affecte directement l'argument réel original. ```pseudo-code PROCEDURE IncrementerParReference(REF nombre: ENTIER) // 'REF' indique un passage par référence { nombre = nombre + 1 ECRIRE "Dans la fonction (par référence) : " + nombre // Ex: 11 } // Appel valeur_originale = 10 IncrementerParReference(valeur_originale) ECRIRE "Après la fonction (valeur originale) : " + valeur_originale // Ex: 11 (modifié !) ``` > [!warning] Attention > Le passage par référence doit être utilisé avec prudence car il peut introduire des effets de bord difficiles à déboguer. Il est souvent utilisé pour modifier plusieurs valeurs ou pour des raisons de performance avec de gros objets. Certains langages (comme Python) utilisent un modèle de "passage par partage d'objet" qui se comporte comme le passage par valeur pour les types immuables et comme le passage par référence pour les types mutables. ## 3. Portée des Variables La portée d'une variable définit l'endroit du programme où cette variable est accessible. > [!definition] Variable Locale et Variable Globale > - Une **variable locale** est déclarée à l'intérieur d'une fonction et n'est accessible qu'à l'intérieur de cette fonction. Elle est créée à l'entrée de la fonction et détruite à sa sortie. > - Une **variable globale** est déclarée en dehors de toute fonction et est accessible depuis n'importe quelle partie du programme, y compris à l'intérieur des fonctions. ```pseudo-code VARIABLE GLOBALE compteurGlobal: ENTIER = 0 PROCEDURE MaProcedure() { VARIABLE LOCALE compteurLocal: ENTIER = 10 compteurGlobal = compteurGlobal + 1 // Accès à la variable globale ECRIRE "Local : " + compteurLocal // OK // ECRIRE "Global (dans proc) : " + compteurGlobal // OK } // ECRIRE "Local (hors proc) : " + compteurLocal // ERREUR : compteurLocal n'existe pas ici MaProcedure() ECRIRE "Global (hors proc) : " + compteurGlobal // OK : affiche 1 ``` > [!tip] Astuce > Privilégiez l'utilisation de variables locales et le passage de paramètres pour gérer les données. L'abus de variables globales rend le code plus difficile à suivre et à déboguer, car n'importe quelle partie du programme peut les modifier. ## Résumé Les fonctions sont des outils essentiels en algorithmique pour structurer le code, le rendre modulaire et réutilisable. Elles peuvent prendre des **paramètres** pour opérer sur différentes données et retourner une **valeur** pour communiquer un résultat. La compréhension des mécanismes de **passage par valeur** et **par référence**, ainsi que la notion de **portée des variables**, est fondamentale pour écrire des algorithmes corrects et efficaces. Ces concepts seront directement appliqués lors de l'apprentissage de langages de programmation comme `Python 1`. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]