IV Les sous-programmes

IV-1- La modularité

Sans modularité
160 actions 120 Actions 140 Actions
ALGORITHME Algo1 ALGORITHME Algo2 ALGORITHME Algo3

Début Début Début

Bloc A Bloc A Bloc B

Bloc B
Bloc B
Bloc C Bloc C
Bloc A
Bloc A
Bloc B Bloc B
Bloc B
Fin Fin Fin

Construction séparée :
Avec modularité :

Module A Module B Module C

10 Actions 50 Actions 40 actions

ALGORITHME Algo1 ALGORITHME Algo2 ALGORITHME Algo3

Module A, B, C Module A, B Module A, B,C

Début Début Début

Appel module A Appel module A Appel module B
Appel module B Appel module B Appel module C
Appel module C Appel module A Appel module B
Appel module A Appel module B Fin
Appel module B Fin
Fin

5 Actions 4 Actions 3 Actions

Sans modularité : 420 A ≈ 17 jours

Avec modularité : 112 A ≈ 4.5 jours
(Selon la norme international 25 ligne/jour)

La modularité qui est la base de la programmation structurée consiste tout simplement à

décomposer un problème en un ensemble de modules REUTILSABLES à volonté elle répond
à 2 objectifs fondamentaux
1- transformer un problème parfois extrêmement complexe en N problèmes simples que
l’on résolvera séparément selon la loi « diviser pour régner »

1
 2- trouver la solution d’un problème une seule fois et une seule car dés qu’un module
qui effectue un travail bien particulier est construit, tester et enregistrer on peut le
réutiliser à chaque que l’on souhaite
La modularité est donc la division d’un logiciel en modules (ou sous programmes) ayant
une INTERFACE DEFINIE et un MECANISME qui assure la communication entre les
différents modules.
Sur le plan syntaxique, un module est un ensemble d’actions primitives ADJACENTES,
avec une frontière bien définie. Il est identifie par un nom, qui permet de l’appeler.
Le bute du module est de recevoir des données d’entrées (0 à N) d’effectuer un traitement
sur ces données et de retrouver des résultats.

Type de module

(0,N) entrées (0,N) sorties

Nom de module

Rôle du module
Exemple :

Fonction

X : entier
PREM Booléen

Rôle : Précise si X est

Premier ou non

Il y’a deux types de modules

Fonction

(0, N) entrées
NOM 1 sortie (objet élémentaire)

Rôle : ……………………..

Procédure

(0, N) entrées
NOM (0, N) sorties

Rôle : ……………………..
2
Exemple :
Fonction

N : entier Entier

FIBO

Rôle : donner le N ème terme

de la suite de FIBONACCI

Fonction

N : entier Entier

FACTO

Rôle : donner le N !

Fonction

M : entier
PPCM Entier
N : entier

Rôle : donner le PPCM de M

et N

PROCEDURE
A : réel
N : Entier
B : réel
EQU 2 X1 : réel
C : réel X2 : réel

Rôle : donner les racines d’une équation de

second degré et leur nombre.
PROCEDURE

HEURE

3
Rôle : affiche l’heure système
 Module appelant
ALGORITHME Test
. Type
.
. Module appelé
Module A Module A
Début
.
.
Appel module A
.
.
Fin

Quand l’appel d’un module est rencontré, l’exécution du module appelant est suspendue,
jusqu’à ce que le module appelé soit totalement exécuté, puis l’exécution du module appelant
repart immédiatement après l’appel.
Avantages de la modularité :
1- on procède de façon naturelle à une conception à des algorithmes de manière
descendante, car la conception se fait par AFFINAGE PROGRESSIF.
2- L’étape de conception est simplifiée car les modules appelants et appelés sont
construits de manière séparée.
3- Pour utiliser un module, il faut seulement, savoir ce qu’il fait et non comment il est
construit.
4- Facilité de compréhension des solutions apportées.
5- Le concepteur gagne du temps dans la conception , car il peu construire une
bibliothèque des modules et il est possible de les cataloguer et de les utiliser à
n’importe quel algorithme.
il est donc recommandé d’avoir recours à la modularité systématiquement dans la
construction de nos solutions.

V-2- les fonctions :

V-2-1- les fonctions utilisateurs :

Interface FONCTION

(0, N) entrées
NOM DE LA FONCTION Type du résultat
(Objet élémentaire)

Rôle : ……………………..

V-2-1-1- structure d’une fonction :

4
Entête de la fonction FONCTION nom-de-la-fonction (liste des paramètres d’entrées) : type du
résultat
Déclaration

Début
Corps de la fonction

Nom-de-la-fonctionrésultat de la fonction
Fin

Le corps de la fonction peut contenir toutes les déclarations et structures algorithmiques.

Le résultat doit toujours être transmis dans le nom de la fonction et cette affectation est
généralement, la dernière action de la fonction.
La liste des paramètres formels décrit les paramètres passes à la fonction ainsi que leur type et
mode de passage.

Le mode de passage :
Lorsqu’un paramètre est fourni au module et que l’on souhaite que le module nous restitue la
même valeur que le paramètre avait à l’entrée on effectuera un passage par valeur de ce
paramètre, vrais lorsqu’un paramètre d’entrée est modifié lors de l’exécution du module et
c’est ce contenue modifié que l’on souhaite, on effectuera un passage par variable (par
référence) dans ce cas le paramètre est précède du mot VAR.
Par défaut, c’est le passage par valeur qui est pris en compte il est recommandé de n’utiliser
que le passage par valeur pour les fonctions.

V-2-1-2- appel d’une fonction :

XFACTO(A)
Ecrire (‘ Res=’,FACTO(A))
RPREM(FACTO(A))
L’appel d’une fonction peut se faire en référencent son nom, à droite du symbole d’affectation
ou dans un appel de procédure ou de fonction.
Tous les paramètres doivent être effectifs au moment d’appel.
De plus l’ordre, le nombre et le type des paramètres effectifs (ou actuels) doivent être
identiques à ceux des paramètres formels(ou muet) lors de l’appel.
Lors de l’appel les paramètres formels prennent les valeurs des paramètres effectifs.

Exemple : calcul de la factoriel d’un entier

Fonction

N : entier Entier

FACTO

Rôle : donner le N !

5
Analyse : N !=1×2×3×….×N

FONCTION FACTO (N : entier) : entier

Variables F, i : entier
Début
F1
Pour i allant de 2 à N faire
FF*i
FACTOF
FIN

Algorithme EXEMPLE
Variables x : entier
Début
Lire(x)
Ecrire (‘la factorielle de ‘,x,’est :’, FACTO(x))

FIN

3 3
x N : entier
FACTO
Entier

Calculer le nombre de combinaisons de N objets pris p à p :

Fonction

M : entier
COMB Entier
P : entier

Rôle : fournit le nombre de

combinaisons de N objets pris p à p 

6
 Analyse :
Utiliser la fonction
COMB=FACTO(N)/(FACTO(P)*FACTO(N-P))
FONCTION COMB (N, P : entier) : entier
Fonction FACTO
Début

COMB FACTO(N) div (FACTO(P)*FACTO(N-P))

FIN

Algorithme EXEMPLE
Variables x, y, z : entier
Début
Lire(x, y)
ZCOMB (x, y)
Ecrire (z)
FIN

Paramètres effectifs d’entrées Paramètres formels d’entrées

Fonction
8 8
x M : entier 28 28
COMB Entier z
2 2
y P : entier

Rôle : fournit le nombre de

combinaisons de N objets pris p à p 

V-1-2-3- Déclaration en pascal d’une fonction :

FUNCTION Identificateur Liste des paramètres :

formels d’entrées

Type de résultat ; Corps de la fonction ;

STRING 7
 Liste des paramètres formels d’entrées :

( Identificateur :
Type de
)
résultat

va
rr

con
st

 Passage par constante (propre au pascal) 

13 13
Et je lui interdis de modifier N dans le module.
Entrée N Sortie N

V-8- comment cataloguer un module :

Programme test ;
Var x :integer ;
FUNCTION FACTO(N :integer) :longint ;
Var F,i :integer ;
Begin
F :=i ;
For i:=2 to N do F:=F*i;
FACTO:=F;
End;

Begin
Read(x);
Write(FACTO(x));
End.

étapes: une fois la conception terminée:

1) test et mise au point du module : integrer le module dans un programme appelant (tres
simplifié)

ALT SAVE A :test.pas

8
 Une fois que le module donne des resultats corrects.
2) cataloguer le module :
On ne laisse que les instructions constituant le module
ALT SAVE AS A : FACTO.FON

3- appel du module :
ouvrir fichier TEST.pas
effacer le module
inserrer la declaration {$i A :FACTO.FON}

programme test;
Var x :integer ;
{$i A :FACTO.FON}
Begin
Read(x);
Write(FACTO(x));
End.

V-3- les procedures:

V-3-1- les procedures utilisateur:

Procédure

(0, N) entrées NOM DE LA

PROCEDURE (0, N) sorties

Rôle : ……………………..

3-1-1- la structure d’une procedure:

Entête de la PROCEDURE nom-de-la-procédure (liste des paramètres formels d’entrées et

procédure de sorties) 
Déclaration

Début
Corps de la
procédure
Fin

 On peut utiliser toutes les déclarations et structures algorithmique

 La liste des paramètres formels contient tous les paramètres d’entrées et de sorties
ainsi que leurs types et mode de passage.
 ((le passage dans les procédures est identique à celui des fonctions MAIS TOUS les
paramètres de sortie doivent être définis avec un passage par variable(VAR).))

9
3-1-2- Appel d’une procédure
L’appel est lui-même une action primitive (instruction). Il est composé du nom de la
procédure suivi entre parenthèse de la liste des paramètres effectifs d’E/S séparés par des
virgules.
L’ordre, le nombre et le type des paramètres effectifs doivent être identiques à ceux des
paramètres formels correspondant.

PROCEDURE
A : entier
VAR X : Réel
R : réel
EXEMPLE
VAR Y : Booléen
C : caractère

Rôle : ……………………….

.
.
.
.
.
EXEMPLE(u,m,w,n,l)
.
.
.
Exemple: résolution d’une équation de second degré
PROCEDURE
A : réel
N : Entier
B : réel
EQU 2 X1 : réel
C : réel X2 : réel

Rôle : donne les racines d’une équation de

la forme AX+BX+C
(NOTA : N indique le nombre de racines).
La structure du module EQU2
Analyse :
On calcule Δ=B^2-4AC
Si Δ >0 : 2 racines distinctes
X1=-B-RACINE Δ/2A
X2=-B+RACINE Δ/2A
Si Δ =0 : racine simple
X1=X2=-B/2A
Si Δ <0 : pas de racines.

10
 Procedure equ2(a,b,c :reél ;var N :entier ;VAR X1 ,X2,X3:réel)
Variable delta:réel

Debut
DeltaSQR(b)-4*a*c
Si delta >0 alors
Dsi
X1(-b-sqrt(delta))/(2*a)
X2(-b+sqrt(delta)/(2*a)
N2
Fsi
Si non
Si delta =0 alors
Dsi non
X1-b/(2*a)
X2X1
N1
Fsi non
Si non N0
FIN

Algorithme appel
Variables u,v,w,m,n:réel
NB : entier
Procédure equ2
Debut
Lire(u,v,w)
Equ2(u,v,w,nb,m,n)
Cas NB parmi
0: ecrire(‘pas de racine’)
1: ecrire(‘une racine double X1=X2=’,m)
2: eccrire (‘2 racines X1=’,m,’et X2=’,n)
FIN.

V-3-1-3- déclaration en pascal :

PROCEDURE Identificateur Liste des paramètres ;

formels d’E/S

Corps de la procédure ;

11
PROCEDURE equ2(a,b,c :real ;var N :integer ;VAR X1 ,X2,X3:real);
.
.
.
END;

V-3-2 : les fonctions et procédures standards (bibliothèques ou unités) :

Les procédures et fonctions utilisées couramment sont regroupées en
bibliothèques appelées unités en Turbo Pascal. Dans ce cas on déclare l'utilisation des
bibliothèques dans la partie déclarations du programme en utilisant le mot réservé Uses suivi
des noms des unités.
Le programmeur peut créer de nouvelles unités.

Le Turbo Pascal fournit un certain nombre d'unités prêtes à l'emploi:

• Unité System
Elle contient les procédures et fonctions de base comme Write ou Readln. C'est la
seule unité qui n'a pas besoin d'être déclarée et qui est toujours utilisable.
• Unité Crt
Permet la gestion de l'écran en mode texte, la gestion du clavier, la gestion du son.
• Unité Dos
Permet la gestion des fonctions fournies par le DOS.
• Unité Lst
Permet la gestion de l'imprimante.
• Unité Graph
Permet la gestion de l'écran en mode graphique.

V-3-2-1- Créer ses propres unités :

Il est possible de fabriquer ses propres unités qu’ils pourront être appelés depuis un
programme écrit en Turbo Pascal.
Précisons qu'une unité s'écrit dans un fichier au format PAS. Mais une fois écrite, l'unité doit
impérativement être compilée (au format TPU) pour être utilisable plus tard par un
programme.

V-3-2-2- Structure générale d'une unité

La structure d'une unité est différente de celle d'un programme.

Entête
Cette partie ne contient qu'une ligne commençant par le mot réservé Unit suivi du nom
de l'unité qui sera aussi le nom du fichier TPU produit.
Par exemple : Unit Outils;
Interface
Cette partie commence par le mot réservé INTERFACE.
Elle contient une série de déclarations d'objets qui seront accessibles aux
programmes utilisant l'unité.
On retrouvera :
• Uses suivi des noms d'unités utilisées
• Const suivi des définitions de constantes

12
 • Type suivi des définitions de types de données
• Var suivi des variables déclarées
• les déclarations des procédures et des fonctions partagées, seuls les entêtes
apparaissent ici.
Implémentation
Cette partie commence par le mot réservé IMPLEMENTATION.
Elle peut contenir de nouvelles déclarations d'unités, de constantes, de types ou
de variables, suivis de procédures et fonctions définies entièrement.
Tout ce qui n'a pas été déclaré dans la partie Interface sera invisible pour un
programme utilisant l'unité.
Initialisation de l'unité
C'est la dernière partie de l'unité. Elle commence par un BEGIN et se termine
par un END suivi du point final. Cette partie sera exécutée avant le début du
programme utilisant l'unité.
Exemple :

Unit Tangt;
Var a : Real;
Function Tangente (a : Real) : Real;
IMPLEMENTATION
Function Tangente (a : Real) : Real;
Begin
Tangente := Sin(a) / Cos(a) ;
End;
BEGIN
END.

Et le programme TAN.PAS :

Program Tan;
Uses Tang ;
Var x : Real ;
BEGIN
Write('Entrez un angle en radians : ') ;
ReadLn(x) ;
WriteLn('Voici sa tangente : ',Tangente(2)) ;
END.

V-4 modules internes – modules externes:

Il est conseillé de ne pas emboité les modules internes dans d’autres modules, car ainsi on ne
peut pas les utiliser comme des modules externes

V-5- objet globaux et objets locaux :

13
 Module appelant

Variables X, A, B : réel

Module 1

Variables X : entier

Rep : booléen
Variables u,v,w,m,n:réel
NB :Module
en 2
Variables c

Module 3
Variables V, W, X, Z: reel

 les objets locaux sont définis dans le module ou ils ont été déclares, et ne peuvent être
manipulés que dans ce module.
Ils sont locaux à ce module, et ne sont pas utilisables en dehors.
 les objets globaux sont définis dans un module appelant ils peuvent être manipulés
dans tous les modules appelés par ce module.
L’ensemble des objets ou l’objet est accessible s’appelle la portée.

Portée
Objets
Module 1 Module 2 Module 3 Module appelant
X *
A * * * *
B * * * *
X * *
REP * *
C *
V *
W *
X *
Z *

Les objets globaux nous permettent parfois de gagner du temps et d’éviter des erreurs, il est
donc utile de les utiliser.

V-6- les effets de bord :

Ce sont des anomalies qui apparaissent au niveau des résultats de façon totalement inattendue,
qui sont parfois très difficiles à détecter et à corriger.
Pour les éviter il suffit d’appliquer la règle suivante :
N’utiliser pas, à chaque fois que cela est possible, des variables globales.

14
Si non ne modifier que les objets locaux. (Ce qui veut dire ne pas mettre l’objet G. à gauche
du symbole  .)

Exemple :

Algorithme EFFBORD
Variables A, B, E: entier
Fonction test (c : entier) : entier
Debut
AB*A
BA-C
TestA+B
Fin

debut
A1
B5
E1
Ecrire(test(E))
Ecrire(test(E))
Ecrire(test(E))
fin

Déroulement :

Module appelant Module appelé

A B E C test
1 5 1 1 9
5 4 1 39
20 19 1 759
380 379

15