Vous êtes sur la page 1sur 74

CH IV : LA MODULARITE

IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ


IV.2 DEMARCHE MODULAIRE ET FORMALISME
IV.3 LES FONCTIONS UTILISATEURS
IV.3.1 STRUCTURE D’UNE FONCTION
IV.3.2 APPEL D’UNE FONCTION.
IV.3.3 DECLARATION D’UNE FONCTION.
IV.4 LES PROCÉDURES UTILISATEURS
IV.4.1 STRUCTURE D’UNE PROCEDURE
IV.4.2 APPEL D’UNE PROCEDURE
IV.4.3 DECLARATION D’UNE PROCEDURE
IV.5 LE PASSAGE DES PARAMÈTRES
IV.6 LES FONCTIONS ET PROCEDURES STANDARDS
IV. 7 OBJETS LOCAUX ET OBJETS GLOBAUX
IV.8 LES EFFETS DE BORD
IV.9 MODULES INTERNES ET MODULE EXTERNES
IV.10 COMMENT CATALOGUER UN MODULE ?
IV.11 LE CONCEPT DE BIBLIOTHEQUE ( Application au Pascal)
CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ
« Diviser pou régner »

problème simple → il n'y a pas de difficulté particulière à construire l'algorithme

Problème complexe → une approche très méthodique est indispensable


sinon risque d’aboutir à des coûts de développement très onéreux.
CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

Dans un programme, on peut parfois constater qu'une même


suite d'actions revient plusieurs fois. Il est alors judicieux de
n'écrire cette suite qu'une seule fois, et de l'utiliser autant de
fois que nécessaire

D'autre part, on peut observer que certains groupes d'actions se


rapportent à des traitements différents. Il est alors souhaitable
de représenter chacun d'eux de manière séparée dans un sous-
programme, ce qui permet d'améliorer la compréhension et la
lisibilité du programme (de l'algorithme).

On perçoit alors un programme comme un programme principal


et un ensemble de sous-programmes.
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 3
CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

La modularité qui est la base de la programmation structurée


consiste tout simplement à découper un problème en un
ensemble de modules réutilisables à 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ésoudra séparément

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, testé et enregistré on pourra le réutiliser à volonté

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 4


CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

Les sous-programmes sont utilisés pour deux raisons essentielles :


• quand un même traitement doit être réalisé plusieurs fois dans
un programme (ou qu'il est utilisé dans plusieurs programmes):
on écrit un sous-programme pour ce traitement et on l'appelle à
chaque endroit où l'on en a besoin. On évite ainsi de réécrire
plusieurs fois le code du traitement.
• pour organiser le code, améliorer la conception et la lisibilité
des gros programmes. En effet, le découpage en sous-
programmes permet de traiter séparément les difficultés.
Il existe des sous-programmes standards ou prédéfinis et des sous-
programmes que le programmeur doit construire appelé sous-
programmes utilisateurs

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 5


CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

En résumé, afin de gagner du temps et d’écrire des algorithmes


plus courts et plus structurés on regroupe un ou plusieurs
blocs, qui réalisent un travail bien précis, dans un MODULE,
auquel on donne un nom et que l’on peut ensuite « appeler »
chaque fois qu’on le désire, en faisant seulement référence à
son nom et sans avoir, bien entendu, à le reconstruire.

La modularité présente des avantages qui font qu’il est donc


intéressant même recommandé d’avoir recours à la modularité
systématiquement dans la construction de nos solutions.
CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

ALGORITHME ALGO-1 ALGORITHME ALGO-1


Déclarations MODULE A Déclarations
Modules A, B, C
DEBUT MODULE B
DEBUT
Bloc A
Appel Module A
Bloc B MODULE C
Appel Module B
Bloc C Appel Module C
Bloc A Appel Module A
Bloc B Appel Module B
Bloc A Appel Module A
FIN FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 7


CH IV : LA MODULARITE
IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

MODULE A
ALGORITHME Expire DEBUT
-
Module A -
DEBUT -
- -
- FIN
-
-
Appel Module A
-
-
-
FIN

Appel d'un module

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 8


CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME

COMMENT PROCEDER ?

• 1ère ETAPE : COMPREHENSION DU PROBLEME POSE

• 2ième ETAPE : ANALYSE DU PROBLEME -CONCEPTION


a) Découper le problème.
b) Construire les modules

• 3ième ETAPE – REALISATION


CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME
COMMENT PROCEDER ?

Pour chaque module :


1. - Dessiner le module
2. - Définir son interface ( noms et types des paramètres formels
ainsi que leur mode de passage)
3. - Lui donner un nom. Prenez un nom explicite, qui permettra
par sa simple lecture de savoir ce qu’il fait
4. - Préciser sa nature (procédure ou fonction)
5. - Préciser ce qu'il fait (le QUOI ?) . Le rôle du module a une
importance fondamentale, car si ce dernier est vague, ambiguë
ou incomplet, le module ne sera d’aucune utilité
CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME

un module est considéré comme


étant une boite noire exécutant
une tâche donnée

un module est défini par Type du module


• son nom
0 ou N entrées 0 ou N sorties
• son rôle Nom du module
• son type
• et ses interfaces c-a-d les Rôle du module
données qu’il reçoit en
entrée et les données qu’il
retourne à celui qui l’a appelé

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 11


CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME

Lorsque le module n'a qu'une sortie et de plus c'est une donnée


élémentaire il est dénommé FONCTION, dans le cas contraire c'est
une PROCEDURE (c'est à dire 0 à n sorties de n'importe quel type).

FONCTION

0 ou N entrées 1 sortie ( Donnée élémentaire)


Nom du module

Rôle du module

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 12


CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME

Lorsque le module n'a qu'une sortie et de plus c'est une donnée


élémentaire il est dénommé FONCTION, dans le cas contraire c'est
une PROCEDURE (c'est à dire 0 à n sorties de n'importe quel type).

PROCEDURE

0 ou N entrées 0 ou N sorties
Nom du module

Rôle du module

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 13


CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME
EXEMPLES

FONCTION FONCTION
A : Entier N : Entier
: Entier : Entier
PPCM FIBO
B : Entier
Rôle : Donne le PPCM de A et B Rôle : Donne le Nième élément
de la suite de Fibonacci

FONCTION FONCTION
N : Entier N : Entier
: Entier : Booléen
FACTO PREM

Rôle : Calcule la factorielle de l’entier N Rôle : Vérifie si l’entier N est premier


ou non

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 14


CH IV : LA MODULARITE
IV.2 DEMARCHE MODULAIRE ET FORMALISME
EXEMPLES

PROCEDURE

A ,B,C : Réel X1,X2 : Réel


EQU2
N: Entier
Rôle : Donne le nombre de solutions ainsi
que les racines X1 et X2 d’une équation
du second degré de coefficients A,B,C

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 15


CH IV : LA MODULARITE
APPEL D’UN MODULE
ALGORITHME Exemple MODULE A
Quand l'appel à un Module A

module est rencontré, DEBUT DEBUT

l'exécution du module -
-
appelant est suspendue
-
jusqu'à ce que le module FIN
-
appelé soit totalement
Appel Module A
exécuté, puis l'exécution
-
du module appelant -
repart immédiatement -
après l'appel. FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 16


CH IV : LA MODULARITE
AVANTAGES DE LA MODULARITE
• On procède de façon naturelle à une conception des algorithmes de
manières descendante, car le découpage en modules logiquement
cohérents des algorithmes se fait par affinage SUCCESSIF,
• L’étape de conception est simplifiée car les modules appelés et
appelants peuvent être construits de manière séparée,
• Pour utiliser un module, il faut seulement savoir ce qui il fait et non
comment il est construit,
• Facilité de compréhension des algorithmes donc des solutions
apportées,
• L'utilisateur gagne du temps dans la conception, car il peut construire
une bibliothèque des modules.
• Il est donc recommandé d'avoir recours à la modularité
systématiquement dans la construction des solutions de problèmes.
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 17
CH IV : LA MODULARITE
IV.3 LES FONCTIONS UTILISATEURS

Une fonction est un module (sous-programme) qui fournit un


résultat unique (donnée élémentaire) à partir de 0 à n
paramètres d'entrées.
La fonction est définie dans un TYPE

FONCTION

0 ou N entrées 1 sortie ( Donnée élémentaire)


Nom du module

Rôle du module

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 18


CH IV : LA MODULARITE
IV.4 STRUCTURE D’UNE FONCTION

En-tête de la fonction FONCTION Nom_de_fonction (paramètres formels d’entrée) : Type du résultat

Partie déclaration Déclarations

DEBUT
-
-
Corps de la fonction
-
Nom_de_fonction  résultat de la fonction
FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 19


CH IV : LA MODULARITE
IV.4 STRUCTURE D’UNE FONCTION

STRUCTURE D’UNE FONCTION EN PASCAL


En-tête de fonction

Liste de Identificateur
Function Identificateur : de Type
paramètres

Liste de paramètres
;
Var
( : Identificateur
Identificateur )
de Type
,
APPEL D’UNE FONCTION
L’appel d’une fonction se fait en citant son nom suivi de la liste des
paramètres réels dans une expression

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 20


CH IV : LA MODULARITE
IV.4 STRUCTURE D’UNE FONCTION

EXEMPLES Type du résultat =


type de la fonction
Déclarations d’entêtes de fonctions
FONCTION PPCM (A,B : ENTIER) : ENTIER
FONCTION FIBO (N : ENTIER) : ENTIER Paramètres formels
FONCTION PREMIER (N : ENTIER) : BOOLEEN
FONCTION FACTO (X : ENTIER) : ENTIER
Appel de fonctions
Paramètres réels
Ecrire (‘Le PPCM de ‘,i,’ ‘,j ,’ est : ’,PPCM(i , j))
Ecrire (‘Le ‘ ,n,’ ième terme de la suite est : ’,FIBO(N))
SI PREMIER (I*J +25) ALORS …
Appel de la fonction

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 21


CH IV : LA MODULARITE
IV.4 STRUCTURE D’UNE FONCTION

ATTENTION
Le nombre de paramètres réels doit être égal à celui des paramètres formels
L’ordre des paramètres réels doit être celui des paramètres formels
Il doit y avoir compatibilité de types entre les paramètres formels et réels

FONCTION PPCM (A , B : ENTIER) : ENTIER

Ecrire (‘Le PPCM de ‘,i,’ ‘,j ,’ est : ’, PPCM( i , j))


I et j doivent être de type ENTIER

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 22


CH IV : LA MODULARITE
IV.5 EXEMPLES
Calcul de la factorielle d'un nombre.

FONCTION ANALYSE
N : Entier : Entier N! = 1*2*3*4*…..*(N-2)* (N-1)*N
FACTO N! = N*(N-1)!

Rôle : Calcule la factorielle de l’entier N

ALGORITHME exple_1 FONCTION FACTO (N: entier) : Entier


variable X : entier Variables F, i : entier (* Var locales*)
fonction FACTO DEBUT
DEBUT F1
POUR i ALLANT de 2 A N FAIRE
lire(X)
F F*i
écrire (FACTO ( X) ) FACTO F (*Retour du résultat*)
FIN FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 23


CH IV : LA MODULARITE
IV.5 EXEMPLES
Calculer le nombre de combinaisons de N objets pris P à P et celui du nombre
d'arrangements de N sachant que C np = n! / p ! (n-p) ! et A np = n ! / (n-p)!
ALGORITHME exple2
Analyse FONCTION Variables a, x ,y : entier FONCTION
n : Entier n : Entier
• Soient deux entiers x et y: Entier Fonctions COMB, ARRANGE ARRANGE : Entier
p : Entier COMB p : Entier
• Calculer et écrire le nombre DEBUT
de combinaisons lire ( x, y )
Rôle : Donne le nombre de combinaisons de n Rôle : Donne le nombre de d’arrangements de n
• Calculer et pécrire
objets pris àp le nombre écrire ( 'Le nombre depris
objets combinaisons
pàp est : ', COMB ( x, y ) )
d’arrangements aARRANGE (x,y)
Analyse : C np = n! / p ! (n-p) ! écrire (' le nombre
Analysed'arrangements
: A np = n ! / est : ', a ).
(n-p)!
FIN
FONCTION COMB (n, p: entier) : entier FONCTION ARRANGE (n, p: entier) : entier
Fonction facto Fonction facto

DEBUT DEBUT
COMB  facto (n ) div ( facto (p) * facto ( n- p )) ARRANGE facto (n ) div facto ( n- p ))
FIN FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 24


CH IV : LA MODULARITE
IV.5 EXEMPLES

ALGORITHME FONCTION

8 8
ARRANGE (X,Y) X N ARRANGE 56
2 2
Y P

ARRANGE (X,Y)

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 25


CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS

LES PROCEDURES UTILISATEURS


Une procédure est un module (sous-programme) qui fournit 0 à N résultat
à partir de 0 à n paramètres d'entrées.

PROCEDURE

0 ou N entrées 0 ou N sorties
Nom du module

Rôle du module

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 26


CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS

STRUCTURE D’UNE PROCEDURE

En-tête de la procédure PROCEDURE Nom_de_Procédure (paramètres formels )

Partie déclaration Déclarations

DEBUT
-
-
Corps de la procédure
-
-
FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 27


CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS

STRUCTURE D’UNE PROCEDURE EN PASCAL


En-tête de Procédure

Procedure Liste de
Identificateur
paramètres

Liste de paramètres
;
Var
( : Identificateur
Identificateur )
de Type
,

APPEL D’UNE PROCEDURE


L’appel d’une procédure se fait en citant son nom suivi de la liste
des paramètres réels comme une instruction

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 28


CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS
EXEMPLE

Déclaration d’entête de procédure


PROCEDURE EQU2 (A,B,C : REEL ; VAR N : ENTIER ; VAR X1,X2 : REEL)

L’absence de VAR indique que le mode de passage


des paramètres est un mode par valeur
VAR indique que le
Paramètres formels mode de passage des
Appel de Procédure (6 paramètres) paramètres est un mode
EQU2 (i , j ,k , nb , r1 , r2) par variable

EQU2 (-2.0, 3.0 ,1 , nb , r1 , r2)


Appel de la procédure Paramètres réels
(6 paramètres)

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 29


CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS
EXEMPLE
Exemple: Ecrire un algorithme qui permet de résoudre une équation du 2nd
degré dont les coefficients a , b , c sont lus au clavier.
ALGORITHME Exemple_Proc
Variables
ANALYSE
E, f, g, S1, S2 : réel
-Soient 3 nombre réels a, b , c
Nb : entier
-Résoudre l’équation du 2nd degré
Procédure EQU2
-Cas nombre de solutions Nb parmi
DEBUT
-0 : écrire (‘Pas de solutions’) Ecrire (' Donner les paramètres a, b et c : ‘)
-1 : écrire (‘Une racine double’ Lire (e, f, g)
EQU_2 (E, F, G, NB, S1, S2)
-2 : écrire (‘deux racines distinctes’ CAS Nb parmi
0 : écrire ('Pas de solutions’ )
Fin cas
1 : écrire ('Une racine double X1 = X2 = ', S1)
2 : écrire ('Deux racines distinctes, X1 =', S1,' et X2 =’,S2)
FINCAS
FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 30


CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS
EXEMPLE
PROCEDURE EQU2 (a, b, c : réel ; var N : entier ; var XI, X2 : réel)
variable delta : réel
PROCEDURE
Analyse DEBUT
Calcul de Delta = b*b – 4*a*c Delta  SQR (B)-4*A*C
Si Delta < 0 Alors nb 0 A ,B,C : Réel SI deltaX1,X2
>0 ALORS : Réel
Sinon Si Delta = 0 alors EQU2 DSI
Xl (-B-SQRT (delta))/ (2*A)
dsi
N: Entier (delta))/ (2*A)
X2(-B+SQRT
nb  1 N2
x1  -b / (2*a)
Rôle : Donne le nombre deFSIsolutions ainsi
x2  x1 SINON
que les racines X1 et X2 d’une équation
fsi DSIN
Sinon du second degré de coefficients A,B,C
SI delta = 0 ALORS
dsin DSI
X1 - B/(2*A)
nb  2
X2X1
x1  (-B-SQRT (delta))/ (2*A) N1
x2  (-B+SQRT (delta))/ (2*A) FSI
fsin SINON
N0
FSIN
FIN
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 31
CH IV : LA MODULARITE
IV.6 LES PROCEDURES UTILISATEURS
EXEMPLE
ALGORITHME PROCEDURE

-1.0 2.0 3.0 -1.0 2.0 3.0


e f g a b c
16.0
delta
3.0 -1.0 2
S1 S2 Nb
X1 X2 N

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 32


CH IV : LA MODULARITE
VI.5 LES PARAMÈTRES ET LEURS MODES DE PASSAGE

Les modules communiquent entre eux par l’intermédiaire de


paramètres.
Les paramètres déclarés et utilisés dans les modules sont appelés
paramètres formels;
les valeurs spécifiées à l'appel sont appelées paramètres Réels.
Si le paramètre est transmis de l’extérieur vers l’intérieur du module
on parle dans ce cas de paramètres d’entrée
Si le paramètre sert à retourner une valeur de l’intérieur vers
l’extérieur du module on parle alors de paramètre de sortie.
Lors de la déclaration des paramètres formels nous devons spécifier
le mode de passage de ce paramètre; c’est-à-dire indiquer s’il est en
entrée ou en sortie ou en entrée sortie (MAJ)

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 33


CH IV : LA MODULARITE
VI.5 LES PARAMÈTRES ET LEURS MODES DE PASSAGE
Il existe deux modes de passage des paramètres :
Le mode de passage par valeur
Le mode de passage par référence ou par variable
Le mode de passage d’un paramètre en sortie ou en Maj doit se faire par
variable est alors précédé du mot réservé VAR lors de sa déclaration dans la
liste des paramètres formels
Le passage d'une valeur à un paramètre non précédé du mot réservé VAR est
appelé passage par valeur. En effet cette valeur est copiée dans le paramètre
formel à l'appel du module. Ceci signifie que, même si par la suite la valeur du
paramètre formel est modifiée dans le module, la valeur du paramètre effectif
ne change pas!
Le passage d'une valeur à un paramètre précédé du mot réservé VAR est
appelé passage par référence ou par variable. En fait le paramètre formel n'est
qu'un nouveau nom pour le paramètre effectif! Ceci signifie que, si par la suite
la valeur du paramètre formel est modifiée, la valeur du paramètre effectif l'est
de la même manière!
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 34
CH IV : LA MODULARITE
IV.6 LES FONCTIONS ET PROCEDURES STANDARDS
Nom Algorithmique Nom en Type du
Pascal Type de x résultat Rôle Exemples
Abs (x) ABS (x) entier/réel type de x valeur absolue de x ABS (-4) = 4 ; ABS (-5.7) = 5.7
Carré (x) SQR (x) entier/réel type de x carré de x SQR (2) = 4 ; SQR (2.5) = 6.25
Racine Carrée (x) SQRT (x) entier/réel réel racine carrée de x SQRT (25) = 5.00 ; SQRT (6.25) = 2.5
Cos (x) COS (x) entier/réel réel cosinus de x (x en radians) COS (PI/2) = 0.00
Sin (x) SIN (x) entier/réel réel sinus de x (x en radians) SIN (PI/2) = 1.00
Tang (x) TAN (x) entier/réel réel tangente de x (x en radians) TAN (PI) = 0.00
Ln (x) LN (x) entier/réel réel logarithme népérien de x LN (1) = 0.00
Exp (x) EXP (x) entier/réel réel exponentiel de x EXP (0) = 1.00
Tronc (x) TRUNC (x) entier/réel entier partie entière de x TRUNC (3.15) = 3 TRUNC (-3.15) = -3
Ent (x) INT (x) entier/réel réel partie entière de x INT (3.15) = 3.00
Arrondi (x) ROUND (x) entier/réel entier entier le plus proche de x ROUND (9.49) = 9 ROUND (9.5) = 10
Frac (x) FRAC (x) réel réel partie décimale de x FRAC (2.45) = 0.45
Aléa RANDOM réel renvoie un réel aléatoire 0..1 0.36
Aléa (x) RANDOM (x) entier entier renvoie un entier aléatoire Random (7) renvoie un entier dans [0, 6]
dans [ 0, x-1]
Odd (x) ODD (x) entier booléen VRAI si x impair FAUX si x pairODD (3) = True ODD (8) = False
Inc (x) INC (x) ; scalaire type de x Procédure, qui incrémente x INC (x) ; l’équivalent de x 􀃅 x +1
INC(x, n) ; l’équivalent de x 􀃅 x + n
Dec (x) DEC (x) ; scalaire type de x Procédure, qui décrémente x DEC (x) ; l’équivalent de x 􀃅 x - 1
DEC(x, n) ; l’équivalent de x 􀃅 x - n
Pred (x) PRED (x) scalaire type de x prédécesseur de x, s’il existe PRED (5) = 4 ; PRED (‘C’) = ‘B’ PRED (True) = False
Succ (x) SUCC (x) scalaire type de x successeur de x, s’il existe SUCC (5) = 6 ; SUCC (‘C’) = ‘D’ SUCC (False) = True
Chr (x) CHR (x) octet caractère caractère de code ASCII est x CHR (65) = ‘A’
Ord (x) ORD (x) scalaire entier rang de la valeur x ORD(‘A’)=65 ; ORD(18)=18 ; ORD(true)=1
Majus (x) UPCASE (x) caractère caractère majuscule de x, s’il est UPCASE (‘b’) = ‘B’
possible UPCASE (‘B’) = ‘B’
CH IV : LA MODULARITE
IV.6 LES FONCTIONS ET PROCEDURES STANDARDS
Les fonctions standards relatives aux chaînes de caractères

Type des Type du


Nom Algo Nom en Pascal Rôle Exemples
param résultat
Retourne un entier L := Length (‘Fonctions standards'); L = 19
Long (ch) Length (ch) Chaîne Entier représentant la longueur de L := Length ('') ; L= 0
ch. L := Length (‘’’') ; L= 1

Retourne la première P := Pos (‘s', ‘Constitution') ; P = 4


Pos (ch1, Pos (ch1, ch2) Chaîne Entier position de la chaîne ch1 P := Pos (‘tion’, ‘Constitution') ; P = 9
ch2) dans la chaîne ch2 P := Pos (‘c', ‘Constitution') ; P = 0
P := Pos (‘C', ‘Constitution') ; P = 1
Sous_chaîn Copy (ch, p, n) Chaîne, Retourne une sous chaîne CH := Copy ('Language', 4, 5) ; CH = 'guage'
e (ch, p, n) Entier, Chaîne de n caractères à partir de la
Entier position p de la chaîne ch.

Concat Concat (ch1, ch2, …) Chaînes Chaîne Retourne la concaténation CH1 := 'Janvier' ;
(ch1, ch2, de plusieurs chaînes en une CH2 := Concat ('1er', '/', ch1, '/', '2015’) ;
…) seule. C'est l'équivalent de CH2 = '1er/Janvier/2015'
ch1+ch2+…
CH IV : LA MODULARITE
IV.6 LES FONCTIONS ET PROCEDURES STANDARDS
Les procédures standards relatives aux chaînes de caractères
Type des Type du
Nom Algo Nom en Pascal Rôle Exemples
param résultat
Chaîne, Supprime N caractères de CH := ‘Algorithme' ;
Efface Delete (ch, p, n) Entier, Chaîne CH à partir de la position Delete (CH, 1, 4) ; CH devient ‘rithme'
Entier P.
Insère une chaîne CH1 CH1 := BON' ;
Insère Insert (ch1, ch2, p) Chaîne, Chaîne dans une autre CH2 à la CH2 := JOUR' ;
Chaîne, position P. Insert (CH1, CH2, 3) ; CH2 devient ‘BONJOUR'
Entier
Convertit une valeur STR (2012, CH) ; CH = '2014'
Convch Numériq chaîne numérique N en une STR (3.14, CH) ; CH = ‘3.1400000000E+01'
Str (n, ch) ue, chaîne CH. STR (3.14:4:2, CH) ; CH = ‘ 3.14'
Chaîne
convertit une chaîne de VAL (‘2015', n, err) ; n = 2015 et err = 0
Chaîne, caractères CH en une VAL ('20H04', n, err) ; n = 0 et err = 3
Valeur Val (ch, n, err) numériq Entier ou valeur numérique N. De • Si n de type entier, après Val (‘3.14', n, err),
ue, on obtient n = 0 et err = 2
réel plus, elle fournit un code
Entier • Si n de type réel, après Val (‘3.14', n, err),
d'erreur ERR qui indique on obtient n = 3.14 et err = 0
si l'opération s'est
déroulée correctement.
CH IV : LA MODULARITE
IV.7 MODULES INTERNES ET MODULE EXTERNES
CH IV : LA MODULARITE
IV. 8 OBJETS LOCAUX ET OBJETS GLOBAUX

Un bloc correspond à une région d'un programme.


Dans un programme, les blocs peuvent être emboîtés les uns dans les
autres
Cette structure appelée structure de blocs définit des niveaux de blocs:
• Le programme principal forme le bloc de niveau 0
• Les procédures et fonctions déclarées directement dans le
programme principal forment chacune un bloc de niveau 1
• Les procédures et fonctions déclarées dans des procédures ou
fonctions de niveau 1 forment chacune un bloc de niveau 2
• De manière générale: les procédures et fonctions déclarées dans
des procédures ou fonctions de niveau N forment chacune un bloc
de niveau N+1
Le numéro de niveau est appelé la profondeur du niveau. Un bloc de
niveau 5 est plus profond qu'un bloc de niveau 2.

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 39


CH IV : LA MODULARITE
IV. 8 OBJETS LOCAUX ET OBJETS GLOBAUX
PORTÉE D'UN OBJET

Un Objet est connu et utilisable


* dans son bloc de définition dès que l’objet a été déclaré
* dans tous les blocs de niveau plus profond, s'ils sont
déclarés dans et après son bloc de définition.
La région d'un programme dans laquelle peut être utilisé un objet
est appelée portée de l‘objet.
- Un objet est local à un bloc s'il est déclaré dans la partie
déclarative du bloc.
- Un objet est global à un bloc s'il est déclaré à l'extérieur du bloc
et que le bloc fait partie de la portée de cet identificateur.

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 40


CH IV : LA MODULARITE 1 PROGRAM Blocs_exemple
2 CONST Max = 10 ;
Exemple: 3 VAR Lettre : CHAR;
4 nb : INTEGER;
Programme
5 PROCEDURE Niveau_1 (carac : CHAR);
6 VAR nb : INTEGER;
7 BEGIN (* Niveau_1*)
a
Niveau_1 Niveau_1_Aussi 8 END ; (* Niveau_1*)

9 PROCEDURE Niveau_1_Aussi Régions


10 VAR nb : REAL;
11 PROCEDURE Niveau_2 (carac : CHAR);
Niveau_2
12 VAR nb : INTEGER;
13 c : CHAR;
Cet exemple montre une structure de 14 BEGIN (* Niveau_2*)
blocs à 3 niveaux: le programme b
principal appelé Blocs_exemple forme le 15 END ; (* Niveau_2*)
niveau 0, les procédures niveau_1 et 16 BEGIN (* Niveau_1_Aussi *)
c
niveau_1_Aussi constituent chacune un
17 END ; (* Niveau_1_Aussi *)
bloc et forment le niveau 1, finalement
18 BEGIN (* Blocs_exemple *)
la procédure niveau_2 forme un bloc de d
niveau 2. 19 END. (* Blocs_exemple *)
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 41
CH IV : LA MODULARITE
Considérons les objets déclarés dans le programme . On obtient

-Blocs_exemple id. (nom du programme) unique


- max id. (de constante) déclaré 1 fois
- lettre id. (de variable) déclaré 1 fois
- nb id. (de variable) déclaré 4 fois
-c id. (de variable) déclaré 1 fois
- Carac id. (de paramètre) déclaré 2 fois
- niveau_1 id. (de procédure) déclaré 1 fois
- niveau_1_Aussi id. (de procédure) déclaré 1 fois
- niveau_2 id. (de procédure) déclaré 1 fois

Considérons à présent les régions a, b, c et d. Quels sont les identificateurs utilisables dans
chaque région, et quels objets désignent-ils?
Région a Région b Région c Région d
Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb,
Carac , Niveau_1 Carac , c, Niveau_1 , Niveau_1 , Niveau_1 ,
Niveau_2, Niveau_2, Niveau_1_Aussi
Niveau_1_Aussi Niveau_1_Aussi

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 42


CH IV : LA MODULARITE
Considérons les objets déclarés dans le programme . On obtient

-Blocs_exemple id. (nom du programme) unique


- max id. (de constante) déclaré 1 fois
- lettre id. (de variable) déclaré 1 fois
- nb id. (de variable) déclaré 4 fois
-c id. (de variable) déclaré 1 fois
- Carac id. (de paramètre) déclaré 2 fois
- niveau_1 id.1(de
PROGRAM
procédure)Blocs_exemple déclaré 1 fois
- niveau_1_Aussi id.2(de procédure)
CONST Max = 10 ; déclaré 1 fois
- niveau_2 id.3(de procédure)
VAR Lettre : CHAR; déclaré 1 fois
4 nb : INTEGER;
Considérons à présent les régions a, b, c et d. Quels sont les identificateurs utilisables dans
chaque région, et quels objets
5 désignent-ils?
PROCEDURE Niveau_1 (carac : CHAR);
Région a 6
Région b VAR nb : INTEGER;
Région c Région d
7 BEGIN (* Niveau_1*)
Max , lettre, Nb, Max , lettre,a Nb, Max , lettre, Nb, Max , lettre, Nb,
Carac , Niveau_1 Carac
8 , c,ENDNiveau_1 , Niveau_1 ,
; (* Niveau_1*) Niveau_1 ,
Niveau_2, Niveau_2, Niveau_1_Aussi
Niveau_1_Aussi Niveau_1_Aussi

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 43


CH IV : LA MODULARITE
1 PROGRAM Blocs_exemple
Considérons les objets déclarés dans le programme
2 CONST. On obtient
Max = 10 ;
3 VAR Lettre : CHAR;
-Blocs_exemple id. (nom du programme)
4 unique
nb : INTEGER;
- max id. (de constante) déclaré 1 fois
- lettre id. (de variable) 5 PROCEDUREdéclaré Niveau_1 (carac : CHAR);
1 fois
- nb id. (de variable) 6 déclaré 4 fois
-c id. (de variable) 7 déclaré 1 fois
- Carac id. (de paramètre) déclaré 2 fois
- niveau_1 id. (de procédure) 8 déclaré 1 fois
- niveau_1_Aussi id. (de procédure) déclaré 1 fois
PROCEDURE Niveau_1_Aussi
- niveau_2 id. (de procédure) 9 déclaré 1 fois
VAR nb : REAL;
Considérons à présent les régions a, b, c et10
d. Quels sont les identificateurs utilisables dans
11
chaque région, et quels objets désignent-ils?
12 PROCEDURE Niveau_2 (carac : CHAR);
Région a Région b VAR nb
13 Région c : INTEGER; Région d
14 c : CHAR;
Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb,
BEGIN (* Niveau_2*) Max , lettre, Nb,
Carac , Niveau_1 Carac , c, Niveau_1 , Niveau_1 , Niveau_1 ,
15
Niveau_2, Niveau_2, Niveau_1_Aussi
16 END ; (* Niveau_2*)
Niveau_1_Aussi Niveau_1_Aussi
17

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 44


CH IV
1 PROGRAM Blocs_exemple
: LA MODULARITE
Considérons les objets déclarés dans le programme . On obtient
2 CONST Max = 10 ;
3 VAR
-Blocs_exemple Lettre
id.:(nom
CHAR;du programme) unique
- max4 nb : id.
INTEGER;
(de constante) déclaré 1 fois
- lettre PROCEDURE id. (de variable)
Niveau_1 ; déclaré 1 fois
- nb 5 id. (de variable) déclaré 4 fois
-c 6 id. (de variable) déclaré 1 fois
7
- Carac id. (de paramètre) déclaré 2 fois
- niveau_1 id. (de procédure) déclaré 1 fois
8
- niveau_1_Aussi id. (de procédure) déclaré 1 fois
- niveau_2 id. (de procédure) déclaré 1 fois
9 PROCEDURE Niveau_1_Aussi
10 VAR nb : REAL;
ConsidéronsPROCEDURE
à présent lesNiveau_2
régions a,; b, c et d. Quels sont les identificateurs utilisables dans
11
chaque région, et quels objets désignent-ils?
12
Région 13 a Région b Région c Région d
14
Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb,
Carac 15, Niveau_1 Carac , c, Niveau_1 , Niveau_1 , Niveau_1 ,
Niveau_2, *)
16 BEGIN (* Niveau_1_Aussi Niveau_2, Niveau_1_Aussi
c Niveau_1_Aussi Niveau_1_Aussi
17 END ; (* Niveau_1_Aussi *)

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 45


CH IV : LA MODULARITE
Considérons les objets déclarés dans le programme . On obtient
1 PROGRAM Blocs_exemple
-Blocs_exemple id. (nom
2 du programme)
CONST Max = 10 ; unique
- max id. (de
3 constante)
VAR Lettre : CHAR; déclaré 1 fois
- lettre id. (de
4 variable) nb : INTEGER; déclaré 1 fois
- nb id. (de variable) déclaré 4 fois
-c id. (de PROCEDURE Niveau_1
5 variable) déclaré 1 fois
- Carac id. (de
6 paramètre) déclaré 2 fois
- niveau_1 id. (de
7 procédure) déclaré 1 fois
- niveau_1_Aussi id. (de procédure) déclaré 1 fois
- niveau_2 id. (de
8 procédure) déclaré 1 fois

9 PROCEDURE
Considérons à présent les régions a, b, c et d.Niveau_1_Aussi
Quels sont les identificateurs utilisables dans
10 désignent-ils?
chaque région, et quels objets
11
Région a Région
12 b Région c Région d
Max , lettre, Nb, Max13, lettre, Nb, Max , lettre, Nb, Max , lettre, Nb,
Carac , Niveau_1 14
Carac , c, Niveau_1 , Niveau_1 , Niveau_1 ,
Niveau_2, Niveau_2, Niveau_1_Aussi
15
Niveau_1_Aussi Niveau_1_Aussi
16
d
17
18 BEGIN (* Blocs_exemple *)
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 46
CH IV : LA MODULARITE
Considérons les objets déclarés dans le programme . On obtient

-Blocs_exemple id. (nom du programme) unique


- max id. (de constante) déclaré 1 fois
- lettre id. (de variable) déclaré 1 fois
- nb id. (de variable) déclaré 4 fois
-c id. (de variable) déclaré 1 fois
- Carac id. (de paramètre) déclaré 2 fois
- niveau_1 id. (de procédure) déclaré 1 fois
- niveau_1_Aussi id. (de procédure) déclaré 1 fois
- niveau_2 id. (de procédure) déclaré 1 fois

Considérons à présent les régions a, b, c et d. Quels sont les identificateurs utilisables dans
chaque région, et quels objets désignent-ils?
Région a Région b Région c Région d
Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb, Max , lettre, Nb,
Carac , Niveau_1 Carac , c, Niveau_1 , Niveau_1 , Niveau_1 ,
Niveau_2, Niveau_2, Niveau_1_Aussi
Niveau_1_Aussi Niveau_1_Aussi

Remarque importante
plusieurs objets déclarés dans des blocs différents peuvent porter le même nom sans que l'on
risque de les confondre!
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 47
CH IV : LA MODULARITE
IV. 9 LES EFFETS DE BORD

ALGORITHME effet_Bord Module Appelant


Variables A, B, E : Entier
A B E Module Appelé
FONCTION test (C : entier) : Entier
1 5 1 C TEST
DEBUT
5 4 1 9
A A*B
BA-C 20 19 1 39
Test A+B
FIN 380 379 1 759
DEBUT
A1
B5 Pour éviter les effets de bord , il suffit
E1
Ecrire (TEST(E))
d'appliquer la règle suivante :
Ecrire (TEST(E)) N'utilisez pas, à chaque fois que cela est
Ecrire (TEST(E)) possible, des variables globales dans un
FIN module, Sinon ne modifier que les objets
locaux.

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 48


CH IV : LA MODULARITE
EXEMPLE

ANALYSE GENERALE
Enoncé : Ecrire
- Soient Clé etun
TFprogramme
deux entiers qui permet de transformer une clé
d’enregistrement
- On décomposedonnée ( entier
la Clé chiffre sur 7 positions) en une adresse
par chiffre
-Pour chaque
par la méthode dite chiffre obtenu Cette méthode consiste à faire
de traduction.
Somme  Somme + Clé Mod 10 * Premproch (i*100) où i
la somme de- toutes les positions de la clé multipliées par le
représente la position dans la Clé de droite à gauche
nombre premier - I lei +plus
1 proche de 100,200,300…,700 , puis à
extraire
- onàextrait
gauche autant
à gauche de positions
autant de positionsque
quel’adresse doitavoir
l’adresse doit en avoir. Ce
nombre de positions
Ce nombre est déterminée
de positions est déterminéparpar la taille du fichier qui est
le nombre
d’enregistrements du fichier c-à-d sa taille et correspond au nombre de
donnée.
positions de TF

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 49


CH IV : LA MODULARITE
EXEMPLE
ALGORITHME Traduc
VAR
Clé , Clé_Sauv, TF , I , S : ENTIER
FONCTION PremProch ( N : ENTIER) : ENTIER
FONCTION ExtGauche ( N , T : ENTIER) : ENTIER
DEBUT
LIRE (Clé , TF)
Clé_Sauv  Clé
S0
i1
TANT QUE Clé_Sauv <> 0 FAIRE
DTQ
S  S + Clé_Sauv MOD 10 * Premproch (i*100)
i  i+1
Clé_Sauv  Clé_Sauv DIV 10
FTQ

ECRIRE (‘L’’adresse correspondant à’ , Clé , ‘ est : ‘, ExtGauche (S,TF))


FIN
CH IV : LA MODULARITE
ETUDE DES MODULES

1- MODULE PREMPROCH
A- SCHEMA

FONCTION

N : Entier : Entier
PREMPROCH

Fournit le nombre premier le


plus proche de N

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 51


CH IV : LA MODULARITE
1- MODULE PREMPROCH
C- ALGORITHME
Fonction PREMPROCH ( n : entier ) : entier
Variables inf, sup : entier
Fonction PREM ( N : ENTIER) : BOOLEEN
B- ANALYSE DEBUT
Inf  n
Analyse : On génère des Sup  n
couples de nombres Inf et TANT QUE NON PREM(inf)
Sup à partir de N dans les ET NON PREM (Sup) FAIRE
deux sens et on s’arrête dès DTQ
que l’on obtient un nombre InfInf-1
premier parmi les nombres SupSup +1
générés FTQ
SI PREM(Inf) ALORS
PREMPROCH  Inf
SINON
PREMPROCH  Sup
03/11/2017 FIN Nadji MEDJAOUI
Cours Algo-Pascal 52
CH IV : LA MODULARITE
2- MODULE EXTGAUCHE

A- SCHEMA

FONCTION
N : Entier
: Entier
T : Entier EXTGAUCHE

Extrait à partir de la gauche de N un nombre


ayant le même nombre de positions que T

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 53


CH IV : LA MODULARITE
2- MODULE EXT_GAUCHE

B- ANALYSE C- ALGORITHME

Fonction EXTGAUCHE (N,T : entier ) : entier


Analyse : On divise N
Fonction PUIS ( B,E: ENTIER) : ENTIER
par 10 puissance (le
Fonction Nbpos ( N: ENTIER) : ENTIER
nombre de positions
de N – le Nombre de
DEBUT
position de T)
EXTGAUCHE  N DIV PUIS (10,Nbpos(N)-Nbpos (T)+1)
FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 54


CH IV : LA MODULARITE
3- MODULE PREM

A- SCHEMA

FONCTION

N : Entier : Booléen
PREM

Vérifie si le nombre N est


premier ou non

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 55


CH IV : LA MODULARITE
3- MODULE PREM

B- ANALYSE C- ALGORITHME

Fonction PREM (N : entier ) : Booléen


Analyse : On génère
Variable i : ENTIER
des diviseurs i à
DEBUT
partir de 2 jusqu’au
i2
lus à N DIV 2. Si
TANT QUE (N MOD I <> 0) ET (I <= N DIV 2) FAIRE
aucun diviseur
I  I +1
généré ne divise N
PREM  (N>1) ET( I > N DIV 2)
alors N est premier
FIN

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 56


CH IV : LA MODULARITE
4- MODULE NBPOS

A- SCHEMA

FONCTION

N : Entier : Entier
NBPOS

Donne le nombre de chiffres


du nombre N

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 57


CH IV : LA MODULARITE
3- MODULE NBPOS

B- ANALYSE C- ALGORITHME

Fonction NBPOS (N : entier ) : ENTIER


Analyse : On divise le
Variable i : ENTIER
nombre N par 10
DEBUT
jusqu’à obtenir un
i1
quotient nul.
TANT QUE N <> 0 FAIRE
Le nombre de
DTQ
divisions représente
I  I +1
le nombre de chiffres
N  N DIV 10
de N
FTQ
NBPOS  I
FIN
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 58
function extgauche PROGRAMME PASCAL
( n ,t : longint) : longint ;
Function Puis ( B , e : longint) : longint ;
Var i : longint ;
program Traduc; Begin
Uses WinCrt p := 1;
var for i := 2 to e do
cle , TF,cle_sauv, S : longint ; p := p*B ;
function PremProch ( N : longint) : longint; puis := p ;
var inf , sup : longint; End ;
function prem ( n : longint) : boolean ; function nbpos (n : longint): longint;
var i: longint ; Var i : longint;
begin Begin
i:= 2 ; i:=1;
while (n mod i <> 0) and ( i <= n div 2) do while n <> 0 do
i:= i+1; begin
prem := (n=2)or ( n mod i = 0) ; i:= i+1; n := n div 10;
end ; end ;
begin nbpos := i;
inf := n ; sup := n ; End;
while not prem(inf) and not prem(sup) do Begin
begin extgauche := n div puis(10,nbpos(n)-nbpos(t)+1) ;
inf := inf -1; End ;
sup:= sup +1; BEGIN (* programme principal*)
end ; Readln(cle,TF) ; cle_sauv : cle ; s:= 0; i:=1;
if prem(inf) then while cle_sauv <> 0 do
premproch := inf begin
else S := S + Cle_Sauv MOD 10 * Premproch (i*100);
premproch= sup; i := i+1; Cle_Sauv := Cle_Sauv DIV 10 ;
end ; End ;
Writeln (‘L’’adresse correspondant à’ , Clé , ‘ est : ‘, ExtGauche(S,TF))
03/11/2017 CoursEND
Algo-Pascal
. Nadji MEDJAOUI 59
CH IV : LA MODULARITE
8- COMMENT CATALOGUER UN MODULE EN PASCAL
1. Utilisation de la directive $i
program Traduc;
Uses WinCrt
var
cle , TF,cle_sauv, S : longint ;
{$i PremProch.Fon}
{$i ExtGauche.Fon}
BEGIN (* programme principal*)
Readln(cle,TF) ; cle_sauv : cle ; s:= 0; i:=1;
while cle_sauv <> 0 do
begin
S := S + Cle_Sauv MOD 10 * Premproch (i*100);
i := i+1;
Cle_Sauv := Cle_Sauv DIV 10 ;
End ;
Writeln (‘L’’adresse correspondant à’ , Clé , ‘ est : ‘,
ExtGauche(S,TF))
END .

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 60


CH IV : LA MODULARITE
10- COMMENT CATALOGUER UN MODULE EN PASCAL
1. Utilisation de la directive $i
program Traduc; function PremProch ( N : longint) : longint;
Uses WinCrt var inf , sup : longint;
var {$i Prem.Fon}
cle , TF,cle_sauv, S : longint ; begin
{$i PremProch.Fon} inf := n ; sup := n ;
{$i ExtGauche.Fon} while not prem (inf) and not prem (sup) do
BEGIN (* programme principal*) begin
Readln(cle,TF) ; cle_sauv : cle ; s:= 0; i:=1; inf := inf -1;
while cle_sauv <> 0 do sup:= sup +1;
begin
end ;
S := S + Cle_Sauv MOD 10 * Premproch (i*100);
i := i+1; if prem(inf) then
Cle_Sauv := Cle_Sauv DIV 10 ; premproch := inf
End ; else
Writeln (‘L’’adresse correspondant à’ , Clé , ‘ est : ‘, premproch= sup;
ExtGauche(S,TF)) end ;
END .

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 61


CH IV : LA MODULARITE
function PremProch ( N : longint) : longint;
var inf , sup : longint;
10- COMMENT CATALOGUER{$i Prem.Fon}
UN
begin
MODULE EN PASCAL
1. Utilisation de la directive
inf :=$i
n; sup := n ;
while not prem (inf) and not prem (sup) do
program Traduc; begin
Uses WinCrt inf := inf -1;
var sup:= sup +1;
cle , TF,cle_sauv, S : longint ; end ;
{$i PremProch.Fon} if prem(inf) then
{$i ExtGauche.Fon} premproch := inf
BEGIN (* programme principal*) else
Readln(cle,TF) ; cle_sauv : cle ; s:= 0; i:=1; premproch= sup;
while cle_sauv <> 0 do
end ;
begin
S := S + Cle_Sauv MOD 10 * Premproch (i*100); function prem ( n : longint) : boolean ;
i := i+1; var i: longint ;
Cle_Sauv := Cle_Sauv DIV 10 ;
begin
End ;
i:= 2 ;
Writeln (‘L’’adresse correspondant à’ , Clé , ‘ est : ‘,
ExtGauche(S,TF)) while (n mod i <> 0) and ( i <= n div 2) do
END . i:= i+1;
prem := (n=2)or ( n mod i = 0) ;
03/11/2017 Cours Algo-Pascalend ; MEDJAOUI
Nadji 62
function extgauche ( n ,t : longint) : longint ;
CH IV : LA MODULARITE{$i nbpos.Fon}
{$i puis.Fon}
10- COMMENT CATALOGUER UN MODULE EN PASCAL Begin
extgauche := n div puis(10,nbpos(n)-
1. Utilisation de la directive $i
nbpos(t)) ;
program Traduc; End ;
Uses WinCrt function nbpos (n : longint): longint;
var
Var i : longint;
cle , TF,cle_sauv, S : longint ;
Begin
{$i PremProch.Fon} i:=1;
{$i ExtGauche.Fon} while n <> 0 do
BEGIN (* programme principal*)
i:= i+1;
Readln(cle,TF) ; cle_sauv : cle ; s:= 0; i:=1;
while cle_sauv <> 0 do
nbpos := i;
begin End;
S := S + Cle_Sauv MOD 10 * Premproch (i*100); Function Puis ( B , e : longint) : longint ;
i := i+1; Var i : longint ;
Cle_Sauv := Cle_Sauv DIV 10 ;
Begin
End ;
Writeln (‘L’’adresse correspondant à’ , Clé , ‘ est : ‘,
p := 1;
ExtGauche(S,TF)) for i := 2 to e do
END . p := p*B ;
puis := p ;
03/11/2017 Cours Algo-PascalEnd ; MEDJAOUI
Nadji 63
CH IV : LA MODULARITE
10- COMMENT CATALOGUER UN MODULE EN PASCAL
2. LE CONCEPT D'UNITE EN TURBO/PASCAL
Lorsque l'on a conçu mis au point et testé un certain nombre de modules, il est
intéressant de les regrouper dans une ou plusieurs bibliothèques appelée UNITES.

COMMENT CONSTRUIRE UNE UNITE


• Taper l'unité comme s'il s'agit d'un programme Pascal,
• A la fin, donner un nom à l'unité, par exemple BIBLIO_1.PAS et sauvegarder le fichier,
• Compiler maintenant l'unité (ALT C) en laissant le commutateur DESTINATION sur
MEMORY
• Corriger les erreurs s'il y en a,
• Lorsqu'il n'y a plus d'erreurs :
• Mettre le commutateur DESTINATION sur DISK puis compiler a nouveau l'unité.
Turbo/Pascal va créer un fichier avec l'extension TPU (Turbo Pascal Unit), BIBLIO_1.TPU
• A partir de maintenant, vous pouvez utiliser l'unité créée en mettant dans la clause
USES le nom de l'unité, exemple: USES BIBLIO_1;
• et vous pouvez utiliser tous les modules qui s'y trouvent sans les déclarer
individuellement et surtout sans qu'ils ne soient à chaque fois compilés.

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 64


STRUCTURE D'UNE UNITE
En-tête de l’unité UNIT Nom_de_L’unité ;
INTERFACE

Partie publique USES Liste des unités globales ( si nécessaire)


En-têtes des procédures et fonctions
IMPLEMENTATTON
USES liste des unités locales à Intégrer
Partie non publique Procédures et Fonctions ( complètes : en-têtes et corps)

[BEGIN

Partie optionnelle Partie initialisations commandes ]


END.

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 65


STRUCTURE D'UNE UNITE

• L’en-tête de l’unité commence par le mot réservé unit suivi du


nom de l’unité
• Le mot réservé interface indique le début de la partie visible pour
les autres unités ou applications
• Si l’unité utilise d’autres unités, on les liste après le mot réservé
uses
• juste après le mot réservé interface
• ou juste après le mot réservé implementation
STRUCTURE D'UNE UNITE
Partie interface :

• elle commence par le mot réservé interface et


se termine par le mot réservé implementation
• elle définit ce qui est visible (accessible) `a
n’importe quelle application ou unité utilisant
celle-ci
• on peut y déclarer des constantes, des types
de données, des variables, des procédures et
des fonctions
STRUCTURE D'UNE UNITE
Partie implementation:

• Elle commence par le mot réservé implementation


• Tout ce qui est déclaré dans la partie interface est
accessible au code de la partie implementation
• elle peut avoir ses propres déclarations
supplémentaires, mais celles-ci ne sont pas accessibles
aux programmes ou unités utilisant cette unité
• elle peut avoir une clause uses
• Le corps des routines déclarées dans la partie interface
doit apparaître dans la partie implementation
STRUCTURE D'UNE UNITE
Remarques

• Le nom du fichier contenant l’unité doit être identique à


l’identificateur qui suit le mot réservé unit
• Avec FreePascal, la compilation d’une unité se fait par la
commande fpc. Le compilateur produit deux fichiers :
---.ppu : fichier de description de l’unité
---.o : contient le code de l’unité
• Les deux fichiers sont nécessaires si l’on veut utiliser l’unité dans
un programme
STRUCTURE D'UNE UNITE
Partie initialization

• elle commence par le mot réservé initialization


• elle permet d’initialiser des données que l’unité
utilise ou rend accessibles au moyen de la partie
interface
• lorsqu’une application utilise une unité, le code
de la partie initialisation est exécuté avant toute
autre partie du code.
UNIT BIBLIO 1;
INTERFACE
(* Dans l'interface on met uniquement les en-têtes des modules *)
FUNCTION FACTO (x : integer) : longint;
FUNCTI0N PREM (n : longint): boolean;
IMPLEMENTATION
(* Dans l'implémentation on intègre les modules en entiere *)
FUNCTION facto(x : integer) : longint;
Var f, i : integer; PROGRAM exemple;
BEGIN USES BiBLIO1 ; (* Utilisation de l'unité BIBLIO_1 *)
f:=1; VAR a :longint;
for i:=2 to x do BEGIN
f:=f*i ; WRITE ('Donner A :’);
facto := f ; READLN(a);
END;
WRITE (facto(a),' ',prem(a));
FUNCTION PREM (n:Iongint):boolean;
VAR i: longint; READLN;
BEGIN END.
i:= 2;
WHILE ((n MOD i) <> 0) and (i <= (n DIV 2)) do
i:=i+1 ;
PREM := (N>1) and( i > N Div 2)
END;
END.
7- DEMARCHE MODULAIRE ET FORMALISME
Comment procéder en face d'un problème ?
1ère ETAPE : COMPREHENSION DU PROBLEME POSE
2ième ETAPE - ANALYSE DU PROBLEME
Décomposer le problème en une suite d’actions tout en mettant
en relief les structures de contrôle nécessaires
3ième ETAPE – ALGORITHME GENERAL
• les actions simples seront gardées telles quelles
• les actions complexes sont remplacées par un appel du
module correspondant à l’action (Ces modules doivent être
déclarés dans la partie déclaration de l’algorithme)
• Il faut Garder toujours en tête qu'un module doit avoir
certaines qualités, à savoir :
- La réutilisation ultérieure
- L'indépendance.
Pour cela, il faut éviter, sauf obligation, de mettre des lectures ou
des écritures et d'utiliser des variables globales dans un module
- La simplicité. Un module doit remplir UNE tâche précise.
03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 72
7- DEMARCHE MODULAIRE ET FORMALISME
POUR CHAQUE MODULE CITE PRECEDEMMENT QUE DOIT-ON FAIRE ?
• Dessiner le module
• Le nommer (Nom donné précédemment)
• Préciser sa nature (procédure ou fonction)
• Définir ses interfaces; noms et types des paramètres
formels ainsi que leur mode de passage)
• Préciser son rôle (ce qu'il fait : le QUOI ?)
• Faire son analyse : il faut préciser ici le COMMENT
• Puis enfin écrire son algorithme
NOTE IMPORTANTE : À ce stade on peut constater que des modules
existent déjà. Il s'agira simplement de les réutiliser. On ne construira donc que
les modules qui n'existent pas.

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 73


7- DEMARCHE MODULAIRE ET FORMALISME
ETAPE REALISATION

- Traduire les algorithmes dans un langage donné


- Tester SEPAREMENT les modules
- Tester et mettre au point le programme principal

03/11/2017 Cours Algo-Pascal Nadji MEDJAOUI 74

Vous aimerez peut-être aussi