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

Pourquoi décomposer un programme ?

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.

Qu’est-ce qu’un module ?

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.

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.

Applications directes

Exercice 1 : Créer un programme modulaire qui :

1. lit les notes de 5 élèves,
2. calcule la moyenne,
3. 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.