La modularisation

Note: ce document est dû en grande partie à mon collègue Vincent Echelard.

La technique de développement graduel

Qu'est-ce que le développement graduel ?

C'est une technique de développement qui nous permettra de construire des algorithmes beaucoup plus complexes que ceux que nous avons bâtis jusqu'à présent et qui nous permettra d'aborder le concept de modularisation. Cette méthode est connue sous plusieurs appellations, dont celles “d'approche TOP / DOWN” ou encore de “raffinement graduel”. Cette dernière appellation image bien le principe de développement qui sera ici présenté.

Le principe de base de cette méthode est d'aborder le problème à résoudre de la façon la plus générale possible, en évitant soigneusement de tenter de résoudre immédiatement les détails du problème. Nous produirons donc tout d'abord un algorithme "général" qui utilisera des "instructions" générales (complexes). À l'étape suivante, nous tenterons d'aborder le problème d'une façon plus détaillée ; nous raffinerons donc l'algorithme obtenu à l'étape précédente en simplifiant les instructions complexes qui auront été utilisées. Il est très possible que l'algorithme obtenu à la fin de cette deuxième étape ne soit pas encore suffisamment détaillé pour être codifié en langage. Dans ce cas il faudra recommencer l'étape de raffinement tant et aussi longtemps que l'algorithme contiendra des instructions qui sont trop complexes pour être codifiées.

Exemple: écrire le pseudo-code et le programme qui permet d'afficher la figure ci-dessous.

********
********
********
********
********
********
********
********
********
********

 

Étape I : on aborde le problème de la façon la plus générale possible



Pseudo-code de l'algorithme à l'étape I

Étape II : on raffine notre vision du problème en augmentant le niveau de détail


Pseudo-code de l'algorithme à l'étape II


[Dessiner un rectangle à l'écran]
 MAX_LIGNE <-- 10
 Cpt_Ligne <--1
 Tant que Cpt_Ligne <= MAX_LIGNE
    [Dessiner une ligne]
    Changer de ligne
    Cpt_Ligne <--Cpt_Ligne + 1
Note: jusqu'à présent, cette solution est générale, au sens où elle peut s'appliquer à n'importe quel problème où l'on doit illustrer une figure en deux dimensions.

 

Étape III : on raffine encore notre vision du problème en augmentant le niveau de détail

********
********
********
********
********
********
********
********
********
********

Pseudo-code de l'algorithme à l'étape III

MAX_LIGNE <-- 10
Cpt_Ligne <-- 1
Tant que Cpt_Ligne <= MAX_LIGNE
   [Dessiner une ligne]
   Changer de ligne
   Cpt_Ligne <-- Cpt_Ligne + 1

[Dessiner une ligne]
 MAX_CAR <-- 8
 Cpt_Car <-- 1
 Tant que Cpt_Car <= MAX_CAR
    Ecrire "*"
    Cpt_Car <-- Cpt_Car + 1

Étape IV : On intègre les différents morceaux de l'algorithme

Pseudo-code de l'algorithme à l'étape IV

 
MAX_LIGNE <-- 10
MAX_CAR <-- 8
Cpt_Ligne <-- 1
Tant que Cpt_Ligne <= MAX_LIGNE
   Cpt_Car <-- 1
   Tant que Cpt_Car <= MAX_CAR
      Ecrire "*"
      Cpt_Car <-- Cpt_Car + 1
   Changer_de_ligne
   Cpt_Ligne <-- Cpt_Ligne + 1

Programme C++ équivalent à l'algorithme à l'étape IV

#include <iostream> //Les fonctions d'entrées/sorties
using namespace std; //Formule magique

void main() // Programme principal
{
   const int MAX_LIGNE = 10; // Nb de lignes
   const int MAX_CAR = 8; // Nb de caractères sur une ligne
   int Cpt_Ligne; // Compteur de ligne
   int Cpt_Car; // Compteur de caractères

   Cpt_Ligne = 1;
   while (Cpt_Ligne <= MAX_LIGNE) // Écriture des lignes
   {
      Cpt_Car = 1;
      while (Cpt_Car <= MAX_CAR) // Écriture des caractères d'une ligne
      {
         cout << "*"; // Écriture d'un caractère
         Cpt_Car = Cpt_Car + 1;
      }
      cout << endl; // Changer de ligne
      Cpt_Ligne = Cpt_Ligne + 1;
   }
} // Fin du programme