Cours fonctions procedures et decomposition en algorithmique

Télécharger PDF

Fonctions et Procédures en Algorithmique

Introduction aux Sous-programmes

Les sous-programmes sont des blocs de code conçus pour effectuer une tâche spécifique. Ils permettent de décomposer un problème complexe en sous-problèmes plus petits et plus gérables, facilitant ainsi l'écriture, la lecture et la maintenance des algorithmes.

Analyse Descendante et Sous-programmes

L'approche d'analyse descendante consiste à structurer la spécification d'un problème de manière arborescente. À chaque niveau de cette arborescence, le problème est décomposé en sous-problèmes, puis les solutions de ces sous-problèmes sont combinées pour résoudre le problème courant. Cette méthode est récursive, chaque sous-problème étant résolu par la même approche.

Par exemple, pour écrire un programme qui affiche les nombres parfaits compris entre 0 et un nombre saisi par l'utilisateur (ex: 28 = 1+2+4+7+14), on peut décomposer le problème comme suit :

Demander à l'utilisateur de saisir un entier N.
Savoir si un nombre donné est parfait.
- Savoir si un nombre est diviseur d'un autre nombre.
- Calculer la somme des diviseurs d'un nombre.
Afficher les nombres parfaits entre 0 et N.

En résolvant ces sous-problèmes, le problème initial devient "quasiment" résolu. Ainsi, écrire un programme consiste souvent à assembler des sous-programmes qui résolvent des parties du problème global.

Le programme qui utilise un sous-programme est appelé le programme appelant ou programme principal.

Types de Sous-programmes

En algorithmique, il existe deux types de sous-programmes :

Les fonctions
Les procédures

Chaque sous-programme est obligatoirement caractérisé par un nom.

Les Fonctions

Une fonction est un sous-programme qui prend des données en entrée (paramètres), effectue un traitement, et rend un et un seul résultat.

Déclaration d'une Fonction

La déclaration d'une fonction suit généralement la structure suivante :

Fonction NomDeLaFonction (paramètres et leurs types) : type_valeur_retour_fonction Var variable_locale_1 : type_1; ... Début instructions de la fonction Retourner expression FinFonction

type_valeur_retour_fonction est le type du résultat que la fonction retourne.
liste de paramètres est la liste des paramètres formels en entrée avec leurs types, de la forme p_1: type_1.
Le corps de la fonction doit comporter une instruction Retourner(expression). Cette instruction met fin à l'exécution de la fonction et retourne la valeur de l'expression comme résultat.

Appel d'une Fonction

L'appel d'une fonction se fait par simple écriture de son nom, suivi des paramètres entre parenthèses (les parenthèses sont toujours présentes, même s'il n'y a pas de paramètre).

NomDeLaFonction (liste_de_paramètres_effectifs)

liste_de_paramètres_effectifs est la liste des valeurs passées à la fonction lors de son appel.
L'appel de la fonction retourne une valeur calculée en fonction des paramètres effectifs.
La liste des paramètres effectifs doit être compatible avec la liste des types de paramètres formels définis dans la déclaration de la fonction.

L'appel d'une fonction se fait dans le programme principal ou dans un autre sous-programme. Le résultat étant une valeur, il doit être affecté à une variable ou être utilisé dans une expression.

Exemple d'Appel de Fonction

Considérons la fonction suivante :

Fonction Pair (n : entier) : booléen Début Retourner (n % 2 = 0) FinFonction

Ici, n % 2 = 0 vérifie si le reste de la division de n par 2 est égal à 0, ce qui signifie que n est pair.

Algorithme AppelFonction
Var : c : réel, b : booléen
Début
    b <- Pair(3)
    // Lors de l'appel Pair(3), le paramètre formel 'n' est remplacé par la valeur 3. La fonction retourne FAUX.
    // b aura la valeur FAUX.
Fin

Les Procédures

Une procédure est un sous-programme semblable à une fonction, mais qui ne retourne aucune valeur explicite. Elle est utilisée pour exécuter un ensemble d'instructions ou modifier l'état de variables passées par référence.

Déclaration d'une Procédure

Une procédure s'écrit en dehors du programme principal. Elle peut ne pas avoir de paramètres.

Procédure NomDeLaProcédure (paramètres et leurs types) Var variable_locale_1 : type_1; ... Début instructions de la procédure FinProcédure

Appel d'une Procédure

L'appel d'une procédure se fait dans le programme principal ou dans une autre procédure par une instruction indiquant le nom de la procédure suivi des paramètres entre parenthèses.

Procédure_exemple (...)

Algorithme exempleAppelProcédure
Début
    Procédure_exemple (...)
    // L'appel d'une procédure est une instruction autonome.
    // Contrairement à une fonction, on n'affecte pas le résultat d'une procédure à une variable ni on l'utilise dans une expression.
Fin

Portée d'une Variable

La portée d'une variable est l'ensemble des sous-programmes (et du programme principal) où elle est connue et accessible. Les instructions de ces sous-programmes peuvent lire ou modifier cette variable.

Variable globale : Une variable définie au niveau du programme principal (celui qui s'exécute en premier) est appelée variable globale. Sa portée est totale : tout sous-programme du programme peut lire ou modifier cette variable.
Variable locale : Une variable définie au sein d'un sous-programme est appelée variable locale. La portée d'une variable locale est uniquement le sous-programme où elle est déclarée.
Masquage : Lorsque le nom d'une variable locale est identique à celui d'une variable globale, la variable globale est localement masquée. Dans ce sous-programme, la variable globale est inaccessible ; seule la variable locale est visible.

Paramètres Formels et Effectifs

Les paramètres servent à échanger des données entre le programme appelant (ou le sous-programme appelant) et le sous-programme appelé.

Paramètres formels : Ce sont les paramètres placés dans la déclaration d'un sous-programme. Ces paramètres peuvent prendre toutes les valeurs possibles, mais ils sont abstraits (n'existent pas réellement) avant l'appel.
Paramètres effectifs : Ce sont les paramètres placés dans l'appel d'un sous-programme. Ils contiennent les valeurs réelles pour l'exécution.

Le nombre et le type des paramètres effectifs doivent être égaux et correspondre aux paramètres formels définis dans la déclaration du sous-programme.

Transmission de Paramètres

Il existe deux modes de transmission de paramètres en programmation :

1. Transmission par valeur (en Entrée)

Les valeurs des paramètres effectifs sont copiées et assignées aux paramètres formels correspondants au moment de l'appel.
Dans ce mode, la modification de la valeur des paramètres formels dans le corps du sous-programme ne change pas la valeur des paramètres effectifs du programme appelant. C'est le cas standard pour les fonctions, souvent utilisées pour des paramètres d'entrée.

Exemple de transmission par valeur

Algorithme exemple1
Var a, b : Entier
Fonction abs (unEntier : Entier) : Entier
    Var ValeurAbsolue : Entier
    Début
        Si (unEntier >= 0) alors
            ValeurAbsolue <- unEntier
        Sinon
            ValeurAbsolue <- -unEntier
        Finsi
        Retourner (ValeurAbsolue)
    FinFonction
Début
    écrire("Entrez un entier:")
    lire(a)
    b <- abs(a)
    écrire("la valeur absolue de ", a, " est ", b)
Fin

2. Transmission par référence (ou par adresse, en Sortie ou Entrée/Sortie)

Les adresses mémoire des paramètres effectifs sont transmises. Les paramètres effectifs subissent les mêmes modifications que le paramètre formel dans la procédure.
Remarque : Le paramètre effectif doit être une variable (et non une expression) lors d'une transmission par adresse.

Passage d'arguments dans une Procédure

Les procédures admettent des paramètres avec des modes de passage spécifiques :

En entrée (E) : Similaire au passage par valeur. Les paramètres sont lus mais leurs modifications locales n'affectent pas la variable d'origine.
En sortie (S) : Les paramètres sont initialisés à l'intérieur de la procédure et leur valeur est retournée à l'appelant. C'est un passage par référence.
En entrée/sortie (E/S) : Les paramètres sont initialisés avec une valeur existante et peuvent être modifiés par la procédure. C'est également un passage par référence.

Les paramètres en Entrée sont considérés comme passés par valeur. Les paramètres en Sortie ou en Entrée/Sortie sont considérés comme des paramètres passés par adresse ou par référence.

Déclaration d'une Procédure avec des modes de passage

On déclare une procédure de la façon suivante :

Procédure NomDeLaProcédure ( E paramètre(s) en entrée; S paramètre(s) en sortie; E/S paramètre(s) en entrée/sortie ) Var variable(s) locale(s) Début instructions de la procédure FinProcédure

Et on appelle une procédure comme une fonction, en indiquant les paramètres entre parenthèses.

Exemple 1 : Procédure pour calculer Min et Max

Algorithme exemple
Var entier1, entier2, entier3, min, max : Entier
// Les fonctions minimum3 et maximum3 sont supposées déjà définies.
Procédure calculerMinMax3 (E a, b, c : Entier ; S min3, max3 : Entier)
    Début
        min3 <- minimum3(a, b, c)
        max3 <- maximum3(a, b, c)
    FinProcédure
Début
    écrire("Entrez trois entiers :")
    lire(entier1); lire(entier2); lire(entier3)
    calculerMinMax3(entier1, entier2, entier3, min, max)
    écrire("la valeur la plus petite est ", min, " et la plus grande est ", max)
Fin

Exemple 2 : Procédure d'échange

Algorithme exemple2
Var a, b : entier
Procédure echanger (E/S val1 : entier , E/S val2 : entier)
    Var temp : entier
    Début
        temp <- val1
        val1 <- val2
        val2 <- temp
    FinProcédure
Début
    écrire("Entrez deux entiers :")
    lire(a, b)
    écrire("Avant échange: a = ", a, " et b = ", b)
    echanger(a, b)
    écrire("Après échange: a = ", a, " et b = ", b)
Fin

FAQ sur les Fonctions et Procédures

Qu'est-ce qui distingue une fonction d'une procédure ?

La distinction principale est qu'une fonction est conçue pour calculer et retourner une unique valeur, tandis qu'une procédure exécute une série d'instructions et peut modifier l'état de variables passées par référence, mais ne retourne pas de valeur explicite. Une fonction est souvent utilisée dans une expression, alors qu'une procédure est appelée comme une instruction autonome.

Quand utiliser le passage de paramètres par valeur ou par référence ?

Utilisez le passage par valeur (Entrée) lorsque le sous-programme a uniquement besoin de lire la valeur d'un paramètre sans jamais la modifier pour le programme appelant. Utilisez le passage par référence (Sortie ou Entrée/Sortie) lorsque le sous-programme doit modifier la valeur d'une variable du programme appelant ou retourner plusieurs résultats via les paramètres.

Une variable locale peut-elle avoir le même nom qu'une variable globale ?

Oui, une variable locale peut avoir le même nom qu'une variable globale. Dans ce cas, au sein du sous-programme où la variable locale est déclarée, la variable globale est "masquée" et seule la variable locale est accessible. C'est une bonne pratique de nommer les variables de manière unique pour éviter toute confusion.