Modularité - Pierre Rainero

Algorithme et programmation :
Modularité :
➢Notion de modularité :
On peut tout à fait nommer un ensemble d'actions (=action nommée) , exemple :
De cette manière on peut nommer un groupe d'actions qui se répète en réutilisant le sous-algo :
Cela ayant pour intérêts d'augmenter la lisibilité et la facilité de maintenance, le partage des
taches, la réutilisation et de décomposer le problème.
➢Étapes successives de l'analyse descendante :
Pour chaque sous-problème on écrit un ou des sous-algorithmes, considérés comme des nouvelles
instructions élémentaires (=primitives).
Rappel : Un sous-problème est un élément de la partition des exigences fonctionnelles d'un
problème à résoudre
Un sous-algorithme : -Description de la solution d'un sous-problème
-Regroupement d’un ensemble de primitives sous un même nom (action nommée)
→ Un sous-problème donne lieu à ce que l'on appelle un ''sous-programme''.
Chaque sous-algorithme doit être défini par : un nom, un rôle, un environnement, une description algorithmique.
Catégorie des sous-algorithmes :
➔Les fonctions :
- 0, 1 ou plusieurs paramètres "Donnée"
- Pas de paramètre "Résultat" (pas de printf par exemple)
- Possède obligatoirement une valeur de retour de type simple ou composé (jamais return 0)
➔Les procédures : (''void'' en C)
- 0, 1 ou plusieurs paramètres "Donnée"
- 0, 1 ou plusieurs paramètres "Résultat"
- 0, 1 ou plusieurs paramètres "Donnée-Résultat"
- Pas de retour
Il est nécessaire d’échanger des données entre algorithmes et sous-algorithmes pour cela il existe
deux possibilités :
1. Les variables globales et les variables locales :
- Variables globales : Variables qui sont utilisées dans un sous-algorithme alors qu'elles ne figurent
pas dans son environnement. Elles sont définies dans l'algorithme appelant.
- Variables locales : Variables définies dans l'algorithme où elles sont utilisées.
Algorithme principal : Sous-algorithme :
Début Algo_princ
lire (" %entier ",leNb)
Somme
écrire (" %entier ",leResultat)
Fin
Environnement :
Début Somme
leResultat ← 0
pour K de 1 à leNb
leResultat ← leResultat + K
finPour
Fin
Globales : ''leNb'' et ''leResultat'' (initialisées par l'appel lire
du programme appelant ou le sous-algorithme)
Locales : ''K'' indice de boucle
(←Environnement de l'algorithme principal en variables globales)

2. Les paramètres :
Un paramètre est une variable transmise par l'algorithme appelant à l'algorithme appelé.
Il en existe deux types :
Paramètre formel Paramètre effectif
Paramètre utilisé dans la définition du
sous-algorithme
→ Seulement utile pour le fonctionnement
du sous-algo (ici ''unNb'')
Paramètre utilisé dans les appels des sous-algorithmes,
variable définie dans l'algorithme appelant
→ Existe vraiment (variables de l'algo principal)
(ici ''leCumul'', ''leTotal'', ''leN'', ''laV'')
•Il faut paramétrer la séquence d'instructions commune :
Début somme
laS ← 0
pour K de 1 à unNb
laS ← laS +K
FinPour
retourner laS
Fin
•Ce qui donne ensuite avec le programme principal :
Début SommeA
lire ("%entier ",leN)
leTotal← somme ( leN)
écrire ("%entier ", leTotal)
Fin
Début SommeB
lire("%entier ",laV)
leCumul ← somme (laV)
écrire("%entier ", leCumul)
Fin
Le traitement est en fait identique, les paramètres permettent donc d'utiliser le même
sous-algorithme avec des variables différentes.
Il y quelques règles d'utilisation :
*Il doit y avoir un même nombre de paramètres dans la déclaration du sous algorithme et dans
l'appel de ce sous algorithme.
*La correspondance entre paramètres formels et effectifs est faite par la position du paramètre.
*Le paramètre formel et son paramètre effectif correspondant doivent avoir le même type.
➢Catégories des paramètres :
Paramètre donnée Paramètre résultat
(Uniquement Procédures)
Paramètre donnée-résultat
(Uniquement Procédures)
L'algorithme appelé l'utilise comme
données (''unNb'').
Ces paramètres doivent absolument
avoir une valeur quand ils parviennent
à l'algorithme appelé.
L'algorithme appelé s'en sert
uniquement pour transmettre
des résultats à l'algorithme
appelant.
Valeur indéterminé possible
avant l'appel.
Utilisé comme donnée par l'algorithme
appelée, pour transmettre des résultats
à l'algorithme appelant.
Doit absolument être initialisé avant la
transmission.
➢Retour sur les fonctions :
Une fonction retourne toujours une valeur.
Dans un algorithme l'appel d'une fonction peut
se faire de deux manières :
leNb ← somme(45)
ou
leNb ← 45
écrire(%entier, somme(leNb))

➢Procédures :
Dans un algorithme on appelle une procédure de
cette manière (on rappelle qu'il n'y a aucun
retour) :
Début
lire("%entier",leNb)
AfficherTable(leNb)
ou
AfficherTable(4)
Fin
En C :
Dans un langage de programmation : un sous-algorithme correspond à un sous-programme, une
fonction quand à elle à une fonction et une procédure à une procédure.
➢Déclaration d'une fonction :
type_de_retour nom_de_la_fonction(type_param_1 nom_param_1, …);
exemple : int fonc(int unX, float unY); → Ceci permet un compilation séparée.
En règle générale, on place les prototypes en début de fichier source et les définitions en fin. Ou
même dans un autre fichier source lorsqu'on travail sur un projet suffisamment important.
→ C'est la qu'intervient un troisième fichier ''.h'' qui est déclaré au début des programmes de cette
manière #include "nom_du_point_h.h"
Dans ce dernier on trouve le nom de toutes fonctions et procédures utilisées (il sert en fait de
''lieur'') sous la forme :
type_de_retour nom_de_la_fonction(type_param_1 nom_param_1, …);
void nom_procédure(type_param_1 nom_param_1, ... );
➢Appel d'une fonction :
L'appel d'une fonction en C se fait comme en pseudo-langage dans l'algorithme principal mais en
suivant les règles C (point virgule en fin commande, int pour entier, etc...)
L'instruction ''return'' permet de définir la valeur retournée au programme appelant et met fin à la fonction.
Pour une fonction avec un paramètre de type ''table'' on adopte la syntaxe suivante :
Programme principal : Sous-programme :
int main()
{
int leTab[4]={1,2,3,4};
printf("%d\n",sommeTab(leTab,4));
return 0;
}
int sommeTab(int unTab[ ], int unN)
{
int laS=0;
for(int i=0;i<unN;i++)
laS+=unTab[i];
return laS;
}
Pour une matrice on a :
Programme principal : Sous-programme :
laSommeV=sommeV(laMat,leNbLig,leNbCol); float sommeV(float uneMat[ ][10],int unNbLig,int unNbCol);
➢Procédure simple :
On parle de procédure simple lorsqu'on a pas de paramètre résultat et pas de paramètre donnée-résultat.
• Calculer et afficher la surface d'un rectangle :
void affiche_Surface(float uneLarg, float uneLong);
• Procédure sans paramètre :
void proc() ;
• Procédure avec type tableau :
int main() {
int leTab[4]={1,2,3,4};
afficheTablo(leTab,4);
return 0; }
void afficheTablo(int unTab[], int unN)
{
for(int i=0;i<unN;i++)
printf("%d\t",unTab[i]); }
• Procédure avec type matrice :
Programme principal :
afficher(laMat,4,7);
Sous-programme :
void afficher(float uneMat[20][10],int unNbLig,int unNbCol);