Décomposer un problème et construire des solutions réutilisables

Fiche pédagogique du chapitre

Objectifs d’apprentissage

À la fin de ce chapitre, l’étudiant devra être capable de :

• expliquer le principe de la modularité et son intérêt dans la résolution de problèmes ;
• décomposer un algorithme complexe en sous-programmes cohérents ;
• déclarer et appeler une procédure avec ou sans paramètres ;
• déclarer une fonction et utiliser sa valeur de retour dans une expression ;
• distinguer une procédure d’une fonction ;
• identifier les paramètres formels et les paramètres effectifs ;
• expliquer le passage par valeur et le passage par référence ;
• utiliser des paramètres d’entrée, de sortie et d’entrée-sortie ;
• distinguer une variable locale d’une variable globale ;
• raisonner sur la portée et la durée de vie des variables ;
• tester indépendamment un sous-programme ;
• concevoir un programme modulaire de gestion des notes.

Prérequis

• maîtriser les variables, constantes et types de données ;
• savoir utiliser les structures conditionnelles et répétitives ;
• savoir manipuler les tableaux à une dimension ;
• savoir écrire et tracer un algorithme complet ;
• connaître les principes de test et de validation.

Plan du chapitre

11.1 Principe de la modularité

11.2 Procédures

11.3 Fonctions

11.4 Paramètres

11.5 Portée des variables

Applications, travaux dirigés, corrigés et synthèse

Organisation pédagogique indicative

Introduction à la modularité

Lorsqu’un algorithme devient long, il devient difficile à comprendre, à tester et à modifier. Une méthode efficace consiste à le décomposer en plusieurs sous-programmes. Chaque sous-programme réalise une tâche limitée : lire une valeur, calculer une moyenne, rechercher un maximum, afficher un tableau ou vérifier une condition.

Cette organisation est appelée modularité. Elle permet de construire progressivement une solution à partir de blocs simples. Les fonctions et les procédures constituent les principaux outils de cette décomposition en algorithmique structurée.

Un programme modulaire ne doit pas être une simple découpe arbitraire. Les modules doivent correspondre à des responsabilités cohérentes, posséder des interfaces explicites et limiter leurs dépendances avec le reste du programme.

11.1 Principe de la modularité

11.1.1 Décomposition d’un problème complexe

Décomposer un problème consiste à identifier des sous-problèmes plus simples, puis à définir un sous-programme pour chacun d’eux. Le programme principal organise les appels et coordonne les résultats.

Par exemple, un programme de gestion des notes peut être décomposé en cinq tâches : saisir les notes, vérifier leur validité, calculer la moyenne, déterminer la meilleure note et afficher un bilan.

11.1.2 Réutilisation du code

Un traitement écrit une seule fois peut être appelé plusieurs fois avec des données différentes. Cette réutilisation évite la duplication du code et réduit le risque d’obtenir plusieurs versions incohérentes d’un même calcul.

Exemple de réutilisation d’une fonction

Dans cet exemple, la fonction Carre est définie une seule fois. Elle peut être utilisée dans plusieurs calculs sans réécrire l’expression x × x.

11.1.3 Lisibilité

Des noms de sous-programmes explicites rendent le programme principal proche d’une description du problème. Le lecteur peut comprendre l’enchaînement général sans connaître immédiatement tous les détails de calcul.

11.1.4 Maintenance

La maintenance regroupe les corrections, améliorations et adaptations effectuées après la première version. Si chaque traitement est isolé dans un module, une modification locale influence moins le reste du programme.

• Correction : une erreur dans le calcul de la moyenne est corrigée dans une seule fonction.
• Évolution : une nouvelle règle d’admission peut être ajoutée dans une fonction dédiée.
• Adaptation : l’affichage peut changer sans modifier les calculs.
• Remplacement : un algorithme lent peut être remplacé en conservant la même interface.

11.1.5 Test indépendant

Chaque sous-programme doit pouvoir être testé avec des jeux d’essai spécifiques. Tester indépendamment réduit la difficulté du diagnostic : lorsqu’une fonction Maximum est correcte, on peut se concentrer sur les autres modules.

11.1.6 Cohésion et dépendances

La cohésion mesure à quel point les instructions d’un module participent à une même tâche. Un module cohérent ne mélange pas la saisie, le calcul et l’affichage sans nécessité. Les dépendances doivent également être limitées : les données utiles sont transmises par paramètres plutôt que lues directement dans des variables globales.

11.2 Procédures

11.2.1 Définition

Une procédure est un sous-programme qui réalise une action. Elle peut recevoir des paramètres et modifier certaines données, mais elle ne fournit pas directement une valeur utilisable dans une expression.

Une procédure est adaptée à des actions comme afficher un message, remplir un tableau, échanger deux valeurs, modifier un enregistrement ou produire plusieurs résultats par paramètres de sortie.

11.2.2 Déclaration d’une procédure

Structure générale

La déclaration indique le nom de la procédure, ses paramètres éventuels, ses variables locales et les instructions exécutées lors de chaque appel.

11.2.3 Appel d’une procédure

Appeler une procédure signifie demander l’exécution de ses instructions. Une fois la procédure terminée, l’exécution reprend à l’instruction située immédiatement après l’appel.

Procédure sans paramètre et appels

11.2.4 Procédure avec paramètres

Les paramètres rendent une procédure adaptable. Une même procédure peut produire des résultats différents selon les valeurs transmises lors de l’appel.

Exemple avec deux paramètres d’entrée

11.2.5 Procédures avec ou sans paramètres

11.2.6 Exemple : échange de deux variables

Une procédure d’échange modifie deux variables du programme appelant. Elle utilise donc des paramètres d’entrée-sortie transmis par référence.

Procédure d’échange

11.3 Fonctions

11.3.1 Définition

Une fonction est un sous-programme qui calcule et retourne une valeur. Elle reçoit éventuellement des paramètres et possède un type de retour. La valeur produite peut être affectée à une variable, comparée, affichée ou intégrée dans une expression.

11.3.2 Déclaration d’une fonction

Structure générale

L’instruction Retourner termine la fonction et transmet une valeur au programme appelant. La valeur retournée doit être compatible avec le type annoncé.

11.3.3 Valeur de retour et type retourné

11.3.4 Appel d’une fonction dans une expression

Exemples d’appels

L’appel est remplacé conceptuellement par la valeur retournée. Avant d’évaluer l’expression complète, le système exécute la fonction et récupère son résultat.

11.3.5 Fonction ou procédure ?

Certains langages représentent toutes les routines comme des fonctions, éventuellement sans valeur significative. En pseudo-code, la distinction reste utile pour clarifier l’intention.

11.3.6 Fonctions sans effet de bord

Une fonction sans effet de bord calcule son résultat uniquement à partir de ses paramètres et ne modifie aucune donnée externe. À paramètres identiques, elle retourne le même résultat. Ce comportement facilite les tests et le raisonnement.

11.4 Paramètres

11.4.1 Paramètres formels et effectifs

Les paramètres formels apparaissent dans la déclaration du sous-programme. Ils décrivent les données attendues. Les paramètres effectifs, aussi appelés arguments, sont les valeurs ou variables fournies lors de l’appel.

Paramètres formels et effectifs

11.4.2 Correspondance des paramètres

La correspondance se fait généralement selon l’ordre. Le premier argument est associé au premier paramètre formel, le second au second, etc. Le nombre et les types doivent être compatibles.

11.4.3 Passage par valeur

Lors d’un passage par valeur, le sous-programme reçoit une copie de la valeur. Une modification du paramètre formel ne modifie pas la variable originale du programme appelant.

Effet du passage par valeur

11.4.4 Passage par référence

Lors d’un passage par référence, le paramètre désigne la variable originale. Une modification effectuée dans le sous-programme est donc visible après l’appel. Ce mécanisme est utilisé pour les paramètres de sortie ou d’entrée-sortie.

Effet du passage par référence

11.4.5 Paramètres d’entrée, de sortie et d’entrée-sortie

Procédure produisant deux résultats

11.4.6 Paramètres tableaux

Un tableau peut être transmis comme paramètre. Sa taille logique doit généralement être transmise séparément lorsque le tableau possède une capacité supérieure au nombre d’éléments utilisés.

Fonction recevant un tableau

11.4.7 Validation des paramètres

Un sous-programme doit préciser les conditions nécessaires à son fonctionnement. Ces conditions sont parfois appelées préconditions. Par exemple, une fonction de moyenne suppose n > 0, et une division suppose un diviseur non nul.

11.5 Portée des variables

11.5.1 Variable locale

Une variable locale est déclarée dans un sous-programme. Elle est accessible uniquement à l’intérieur de ce sous-programme. Elle sert aux calculs intermédiaires et disparaît généralement lorsque l’appel se termine.

La variable resultat est locale

Le programme principal ne peut pas utiliser directement resultat. Cette limitation protège les détails internes de la fonction.

11.5.2 Variable globale

Une variable globale est déclarée en dehors des sous-programmes et peut être accessible par plusieurs modules. Elle peut sembler pratique, mais elle crée des dépendances cachées : un module peut modifier une donnée utilisée ailleurs sans que l’appel l’indique.

Exemple d’accès à une variable globale

11.5.3 Durée de vie d’une variable

11.5.4 Masquage de noms

Si une variable locale porte le même nom qu’une variable globale, elle peut masquer la variable globale dans le sous-programme. Cette situation rend la lecture ambiguë et doit être évitée.

Exemple de masquage

11.5.5 Risques liés aux variables globales

• modification involontaire depuis plusieurs sous-programmes ;
• difficulté à savoir quelle instruction a changé la valeur ;
• tests indépendants plus complexes ;
• dépendances cachées entre les modules ;
• réutilisation limitée dans un autre programme ;
• risques supplémentaires lors d’exécutions simultanées.

Applications guidées

Application 1 — Fonction calculant le maximum

Concevoir une fonction qui retourne la plus grande de deux valeurs réelles. En cas d’égalité, la valeur commune est retournée.

Solution

Pour obtenir le maximum de trois valeurs, on peut réutiliser la fonction précédente :

Réutilisation

Application 2 — Fonction vérifiant si un nombre est premier

Un entier n est premier s’il est supérieur ou égal à 2 et s’il possède exactement deux diviseurs positifs : 1 et lui-même. Il suffit de rechercher un diviseur entre 2 et la racine carrée de n.

Solution

Application 3 — Procédure affichant un tableau

La procédure reçoit un tableau et son nombre d’éléments. Elle affiche chaque valeur précédée de son indice.

Solution

Le paramètre T est un paramètre d’entrée : la procédure lit les valeurs sans les modifier.

Application 4 — Fonction calculant la moyenne d’un tableau

La fonction calcule la somme des n valeurs, puis la divise par n. La précondition n > 0 doit être respectée.

Solution

Application 5 — Programme modulaire de gestion des notes

On souhaite saisir les notes d’une classe, calculer la moyenne, déterminer la meilleure note, compter les étudiants admis et afficher un bilan. Une note est valide si elle appartient à l’intervalle [0, 20]. Un étudiant est admis si sa note est supérieure ou égale à 10.

a) Décomposition proposée

b) Validation et saisie

Modules de saisie

c) Calculs

Fonctions de traitement

d) Affichage du bilan

Procédure d’affichage

e) Programme principal

Programme principal

Traçage des appels de sous-programmes

Lors d’un appel, les paramètres sont initialisés, les variables locales sont créées, le corps du module s’exécute, puis la valeur éventuelle est retournée. Le contexte du programme appelant est ensuite repris.

Exemple à tracer

Dans le cas d’appels imbriqués, la fonction la plus interne est évaluée en premier. Par exemple, Maximum(Maximum(3, 7), 5) commence par calculer Maximum(3, 7), puis appelle Maximum(7, 5).

Erreurs fréquentes et bonnes pratiques

Règles de nommage

• Fonctions booléennes : utiliser une question comme EstPremier, NoteValide ou Contient.
• Fonctions de calcul : utiliser un nom comme Moyenne, Maximum ou NombreVoyelles.
• Procédures d’action : utiliser un verbe comme Afficher, Saisir, Trier ou Echanger.
• Paramètres : choisir des noms liés à leur rôle et éviter a, b, c lorsque le contexte est complexe.
• Variables locales : préférer somme, compteur, indice et maximum à des noms génériques.

Travaux dirigés

Exercice 1 — Valeur absolue

Écrire une fonction ValeurAbsolue(x) qui retourne la valeur absolue d’un réel. Proposer des jeux d’essai contenant une valeur positive, une valeur négative et zéro.

Exercice 2 — Pair ou impair

Écrire une fonction EstPair(n) qui retourne Vrai lorsque n est divisible par 2. Utiliser cette fonction dans un programme qui compte les nombres pairs d’un tableau.

Exercice 3 — Conversion de température

Écrire une fonction CelsiusVersFahrenheit(c) utilisant la formule f = 1,8 × c + 32. Écrire ensuite une procédure AfficherConversion(c) qui affiche les deux températures.

Exercice 4 — Minimum et position

Écrire une procédure MinimumEtPosition(T, n, minimum, position) qui produit la plus petite valeur du tableau et sa première position. Identifier le mode de chaque paramètre.

Exercice 5 — Normalisation de notes

Écrire une procédure LimiterNotes(T, n) qui remplace toute note inférieure à 0 par 0 et toute note supérieure à 20 par 20. Le tableau doit-il être transmis en entrée ou en entrée-sortie ? Justifier.

Exercice 6 — Puissance entière

Écrire une fonction Puissance(x, n) qui calcule x puissance n pour n entier positif ou nul, sans utiliser d’opérateur de puissance.

Exercice 7 — Statistiques d’un tableau

Décomposer le calcul du minimum, du maximum, de la somme et de la moyenne en plusieurs fonctions. Écrire une procédure AfficherStatistiques qui utilise ces fonctions.

Exercice 8 — Analyse d’un identifiant

Écrire une fonction IdentifiantValide(texte) qui retourne Vrai si la chaîne contient entre 5 et 12 caractères, commence par une lettre et ne contient que des lettres, des chiffres ou le caractère souligné.

Exercice 9 — Portée des variables

Analyser un pseudo-code contenant une variable globale total et une variable locale portant le même nom. Expliquer quelle variable est utilisée dans chaque instruction et proposer une version sans masquage.

Exercice 10 — Mini-projet modulaire

Concevoir un programme de gestion de cinq produits : saisie des prix, validation, calcul du prix moyen, recherche du prix maximal et affichage des produits dont le prix est supérieur à la moyenne. Proposer les fonctions et procédures nécessaires.

Corrigés indicatifs

Corrigé 1 — Valeur absolue

Corrigé 2 — Pair ou impair

Corrigé 3 — Conversion de température

Corrigé 4 — Minimum et position

Corrigé 5 — Normalisation de notes

Le tableau est un paramètre d’entrée-sortie, car ses valeurs initiales sont lues puis éventuellement modifiées.

Corrigé 6 — Puissance entière

La précondition est n ≥ 0. Pour n = 0, la boucle ne s’exécute pas et la fonction retourne 1.

Corrigé 7 — Statistiques d’un tableau

Une solution modulaire comporte les fonctions SommeTableau, MinimumTableau, MaximumTableau et MoyenneTableau. La procédure AfficherStatistiques appelle ces fonctions et affiche leurs résultats. La fonction MoyenneTableau peut réutiliser SommeTableau afin d’éviter la duplication.

Corrigé 8 — Analyse d’un identifiant

La fonction vérifie d’abord la longueur, puis le premier caractère, puis parcourt tous les caractères. Les fonctions auxiliaires EstLettre et EstChiffre peuvent être réutilisées.

Corrigé 9 — Portée des variables

Lorsqu’un nom local masque un nom global, les instructions du sous-programme utilisent la variable locale. Pour supprimer l’ambiguïté, il faut renommer la variable locale ou, mieux, transmettre la donnée nécessaire par paramètre et éviter la variable globale.

Corrigé 10 — Mini-projet modulaire

Le programme principal lit le nombre de produits, appelle SaisirPrix, calcule la moyenne et le maximum, puis appelle AfficherSuperieurs. Chaque module peut être testé indépendamment.

Synthèse du chapitre

Checklist de conception d’un sous-programme

• Le sous-programme réalise-t-il une seule tâche principale ?
• Son nom décrit-il clairement son rôle ?
• Les paramètres nécessaires sont-ils explicitement déclarés ?
• Le mode entrée, sortie ou entrée-sortie est-il correct ?
• La fonction retourne-t-elle une valeur dans tous les cas ?
• Les variables locales sont-elles correctement initialisées ?
• Les préconditions sont-elles vérifiées ?
• Le module évite-t-il les variables globales inutiles ?
• Peut-il être testé indépendamment avec plusieurs jeux d’essai ?
• Son interface permet-elle une réutilisation dans un autre contexte ?

Glossaire

Auto-évaluation

Pour chaque affirmation, indiquer : acquis, en cours d’acquisition ou à revoir.