Chapitre 7 — La modularité et la décomposition d’un programme

Lorsqu’un programme devient plus long ou plus complexe, il devient difficile de le comprendre, de le corriger ou de le faire évoluer. Pour éviter cela, on apprend à le découper en plusieurs modules : des blocs logiques autonomes, chacun responsable d’une tâche bien précise. Ce principe s’appelle la modularité.

Objectifs pédagogiques

Comprendre la notion de module et son rôle dans la conception d’un algorithme.
Savoir organiser un programme en plusieurs fonctions cohérentes.
Identifier les avantages de la modularité : clarté, réutilisation et maintenance.
Être capable de concevoir une décomposition hiérarchique d’un problème

Plan du chapitre

1. Pourquoi décomposer un programme ?
2. Qu’est-ce qu’un module ?
3. Organisation d’un programme modulaire
4. Communication entre modules
5. Applications directes

Pourquoi décomposer un programme ?

Définition

La décomposition consiste à séparer un problème complexe en sous-problèmes plus simples, appelés modules. Chaque module peut ensuite être développé, testé et corrigé indépendamment des autres.

Un programme complet peut être vu comme une machine composée de plusieurs engrenages :
chaque engrenage joue un rôle spécifique, et l’ensemble ne fonctionne que si chaque partie fait bien son travail.

Par exemple, pour un programme de gestion de notes :

un module s’occupe de la saisie des données,
un autre calcule la moyenne,
un troisième affiche les résultats.

Cette approche permet de raisonner par étapes et de simplifier la mise au point du programme.

Astuce

Avant de coder, prenez l’habitude de découper le problème en sous-tâches logiques. Une bonne question à se poser est : « Puis-je expliquer mon algorithme en trois ou quatre grandes étapes claires ? »

Qu’est-ce qu’un module ?

Définition

Un module est une partie autonome d’un programme qui remplit une fonction précise. Il peut être représenté par une fonction, une procédure, ou même un autre algorithme.

Chaque module peut être vu comme une brique indépendante du programme.
Ces briques peuvent ensuite être assemblées pour construire un système complet.

Exemple

Fonction LireNotes()
    Pour i de 1 à 5
        Lire notes[i]
    FinPour
FinFonction

Fonction CalculMoyenne()
    somme ← 0
    Pour i de 1 à 5
        somme ← somme + notes[i]
    FinPour
    Retourner somme / 5
FinFonction

Fonction AfficherRésultat(moyenne)
    Écrire "Moyenne : ", moyenne
FinFonction

Début
    LireNotes()
    m ← CalculMoyenne()
    AfficherRésultat(m)
Fin

Ici, le programme principal se limite à enchaîner des modules : la lecture, le calcul et l’affichage. Chaque fonction fait une seule chose, ce qui rend l’algorithme lisible et facile à modifier.

Organisation d’un programme modulaire

Un programme bien structuré suit généralement une organisation logique en trois parties :

Partie	Rôle
Déclaration	Définir les variables, constantes et fonctions utilisées.
Corps principal	Décrire le déroulement global du programme.
Modules	Détailler les fonctions appelées dans le corps principal.

Cette structure facilite la compréhension du flux global du programme et évite les répétitions.

On peut comparer cela à un livre :

la table des matières (le corps principal) indique l’ordre,
les chapitres (les fonctions) développent chaque idée séparément.

Communication entre modules

Les modules échangent des données à l’aide de paramètres (entrées) et de valeurs de retour (sorties). C’est ce qui permet à chaque fonction de travailler indépendamment tout en participant à la résolution globale du problème.

Fonction Addition(a, b)
    Retourner a + b
FinFonction

Fonction AfficheSomme()
    Lire x, y
    Écrire "Somme : ", Addition(x, y)
FinFonction

Le module Addition effectue le calcul, tandis que AfficheSomme s’occupe de la saisie et de l’affichage. Cette séparation des rôles rend le code plus clair et plus facile à tester.

Erreur fréquente

Confondre la variable locale d’un module avec une variable globale.
Une variable déclarée à l’intérieur d’une fonction n’existe que dans cette fonction.
Elle disparaît dès que la fonction se termine.

Applications directes

Exercice 1 : Créer un programme modulaire qui :

lit les notes de 5 élèves,
calcule la moyenne,
affiche un message selon le résultat (« Réussi » ou « Échec »).

Exercice 2 : Créer un programme modulaire qui :

lit deux nombres,
affiche leur somme et leur produit,
chaque opération doit être effectuée dans une fonction distincte.

À retenir

La modularité rend un programme plus clair, plus flexible et plus réutilisable.
Chaque module correspond à une fonction qui réalise une tâche précise.
Les modules communiquent grâce aux paramètres et aux valeurs de retour.
Un bon programme est construit comme un ensemble de briques logiques bien ordonnées.

Prochain chapitre

Le prochain chapitre introduira la notion de structures conditionnelles imbriquées et de tests multiples, pour affiner encore la logique des programmes.