5 AlgoCh4 Modularité

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)
« 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.
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
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é

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

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.
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

MODULE A
ALGORITHME Expire DEBUT
-
Module A -
DEBUT -
- -
- FIN
-
-
Appel Module A
-
-
-
FIN
Appel d'un module

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

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é
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é

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

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
Nom du module
Rôle du module

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

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

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

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.
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

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

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

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

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

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

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

IV.5 EXEMPLES
ALGORITHME FONCTION
8 8
ARRANGE (X,Y) X N ARRANGE 56
2 2
Y P
ARRANGE (X,Y)

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
Nom du module
Rôle du module

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

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

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)

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

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
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

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)

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!
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’
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+…
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.
IV.7 MODULES INTERNES ET MODULE EXTERNES
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.

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.

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;
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 *)
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
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


- 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;
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 ,

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;
- 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
- niveau_1 id. (de procédure) 8 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
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,
15
16 END ; (* Niveau_2*)
17

CH IV
: LA MODULARITE
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
8
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
12
Région 13 a Région b Région c Région d
14
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 *)

-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
-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_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 ,
15
16
d
17
18 BEGIN (* Blocs_exemple *)

Région a Région b Région c Région d
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!
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.

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

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
ETUDE DES MODULES
1- MODULE PREMPROCH
A- SCHEMA
FONCTION
N : Entier : Entier
PREMPROCH
Fournit le nombre premier le

plus proche de N

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
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

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

3- MODULE PREM
A- SCHEMA
FONCTION
N : Entier : Booléen
PREM
Vérifie si le nombre N est

premier ou non

3- MODULE PREM
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

4- MODULE NBPOS
A- SCHEMA
FONCTION
N : Entier : Entier
NBPOS
Donne le nombre de chiffres

du nombre N

3- MODULE NBPOS
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
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
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 .

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 .

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;
end ;
begin
S := S + Cle_Sauv MOD 10 * Premproch (i*100); function prem ( n : longint) : boolean ;
i := i+1; var i: longint ;
begin
End ;
i:= 2 ;
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)-
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;
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 ;
Begin
End ;
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
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.

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.

• 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
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
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
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
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.
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.

ETAPE REALISATION
- Traduire les algorithmes dans un langage donné

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

Langue

5 AlgoCh4 Modularité

Transféré par

Informations du document

Description :

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

5 AlgoCh4 Modularité

Titre original :

Transféré par

Description :

Droits d'auteur :

CH IV : LA MODULARITE

IV.1 CONCEPTS FONDAMENTAUX DE LA MODULARITÉ

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

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

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

On perçoit alors un programme comme un programme principal

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

1. Transformer un problème, parfois extrêmement complexe,

2. Trouver la solution d'un problème une seule fois et une seule,

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

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

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

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

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

ALGORITHME ALGO-1 ALGORITHME ALGO-1

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

Appel d'un module

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

• 1ère ETAPE : COMPREHENSION DU PROBLEME POSE

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

• 3ième ETAPE – REALISATION

Pour chaque module :

un module est considéré comme

un module est défini par Type du module

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

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

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

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

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

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

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

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

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

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

module est rencontré, DEBUT DEBUT

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

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

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

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

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

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

STRUCTURE D’UNE FONCTION EN PASCAL

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

EXEMPLES Type du résultat =

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

FONCTION PPCM (A , B : ENTIER) : ENTIER

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

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

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

ALGORITHME exple_1 FONCTION FACTO (N: entier) : Entier

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

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

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

LES PROCEDURES UTILISATEURS

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

STRUCTURE D’UNE PROCEDURE

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

Partie déclaration Déclarations

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