Zinoubi Thameur 1 Lycée 2 Mars 1934 SBZ 1
Chapitre 5: Les sous-programmes Leçon N°1 : l’analyse modulaire
L’analyse modulaire permet de diviser un grand problème en sous problèmes (module) de difficultés
inférieurs pour :
Diminuer les instructions qui se répètent,
Faciliter les taches difficiles.
Exemple :
Soit l'algorithme suivant:
0) Début Exemple
1) [CH1''''] Pour i de P à (P+N)-1 Faire
CH1CH1 +CH[i]
Fin Pour
2) Ecrire (CH1)
3) Fin Exemple
Sachant que :
CH et CH1 : deux chaînes,
N, P et i trois entiers.
o Donner le résultat du programme si CH = "Bonjour", P = 4 et N = 4.
o Déduire le rôle de ce programme
Ce programme permet de copier de CH, N caractères à partir de la position P et le résultat se sera
affecté dans la chaîne CH1.
CH1 Sous-chaine (CH, P, N)
Sous-chaine est une fonction prédéfinie qui facilite la tache à l'utilisateur: au lieu d'écrire le bloc d'instruction
N°1 on l'appelle seulement par les paramètres convenables.
CH1 Sous-chaine (CH, P, N)
La différence entre :
CH1 Sous-chaine (CH, P, N)
Efface (CH, P, N)
La 1ère est une fonction la 2ème est une procédure.
Remarques :
Le sous-programmes permet de découper un gros programme en morceaux plus petits et plus simples à coder
et à comprendre, et permet d'éviter la répétition de plusieurs morceaux identiques. Il possède un nom, des
variables, des instructions, un début et une fin. En effet, l'exécution d'un sous-programme est demandée par le
programme principal (ou un autre sous-programme) grâce à une instruction spécifique qu'on nomme APPEL.
Le programme principal est l'ensemble d'instruction qui s'exécute au lancement de l'application.
Prob
S-P 2
S-P 3
S-P 1
S-P 11 S-P 12
Zinoubi Thameur Lycée 2 Mars 1934 SBZ 2
Leçon N°2: Les fonctions: 1. Définition :
Une fonction est une suite d’instructions décrivant un action simple ou composée, à laquelle on affecte un nom,
qui peut retourner q’un seul résultat. La structure d’une fonction est analogue à la structure d’un algorithme.
2. Syntaxe : Au niveau de l’analyse :
DEF FN Nom_ fonction (liste des paramètres) :type_fonctin
Résultat = Nom_ fonction ………
…………………………….
……………………………
Au niveau de l’algorithme
0) DEF FN Nom_ fonction (liste des paramètres) :type_fonctin
1) ……..….
i-1) Nom_ fonction résultat
i) FIN Nom_ fonction
Au niveau de la traduction en Pascal
Function Nom _ fonction (liste des paramètres) :type_fonctin;
VAR Les déclarations;
BEGIN
Instructions de la fonction;
Nom _ fonction := résultat ;
END;
3. Activité : Ecrire une analyse, un algorithme qui permet de lire deux entiers p et n (n ≥ p ≥ 0) et de calculer et afficher la
combinaison de p objets parmi n.
L’analyse du programme principal: Résultat = Ecrire(C ).
C =[ ] C FN Fact(n)/( FN Fact(p) * FN Fact(n-p))
(n,p) =[ ] Répéter
n, p= Données
Jusqu'à (n ≥ p) et (p ≥ 0)
Fin Combinaison
L’Algorithme du programme principal: 0) Début Combinaison
1) Répéter
Ecrire ('' Donner n et p''), Lire (n,p)
Jusqu'à (n ≥ p) et (p ≥ 0)
2) C FN Fact (n)/ (FN Fact (p) * FN Fact (n-p))
3) Ecrire (C)
4) Fin Combinaison
)!(!
!
pnp
nC p
n
Paramètres Effectifs
L’appel de la fonction
Zinoubi Thameur Lycée 2 Mars 1934 SBZ
Tableau de déclaration des objets globaux
Objet Nature/ Type Rôle
n
p
C
Fact
Entier
Entier
Réel
Fonction
Le 1er entier
Le 2ème entier
Contient la combinaison de p parmi n.
Calculer la factorielle d’un entier.
L’analyse de la fonction Fact:
DEF FN Fact ( x : entier ) : entier
Résultat = Fact f
f =[ ] Selon x faire
0 : f 1
Sinon [f 1] Pour i de 1 à x Faire
f f * i
Fin Pour
FinSelon
Fin Fact
L’Algorithme de la fonction Fact:
0) DEF FN Fact (x : Entier) : entier
1) Selon x faire
0 : f 1
Sinon [f 1] Pour i de 1 à x Faire
f f * i
Fin Pour
FinSelon
2) Fact f
3) Fin Fact
Tableau de déclaration des objets locaux:
Traduction en Turbo pascal :
Program Act ;
Uses wincrt ;
Var n,p: integer ;
C : Real ;
Function Fact ( X: integer): integer ;
Var f,i : integer; Begin
Case X of
0 : f : =1 ;
Else f : = 1;
For i : = 1 to X do
f : = f * i ;
End ;
Fact : = f ;
End;
Begin
Repeat
Writeln (' Donner n et p') ;
Readln (n,p) ;
Until (n >= p) AND (p >= 0) ;
C : = Fact(n)/( Fact(p) * Fact(n-p)) ;
Writeln(' la combinaison est = ',C) ;
End.
Objet Nature/ Type Rôle
i
f
Entier
Entier
Le compteur
Contient la factorielle
Paramètres formels
Zinoubi Thameur Lycée 2 Mars 1934 SBZ
Remarques : L’appel de la fonction dans le programme principale comme suit :
C FN Fact (n)/ (FN Fact (p) * FN Fact (n-p))
Paramètres formels : ce sont les paramètres qui se trouvent dans l’entête de la fonction.
Paramètres effectifs : ce sont les paramètres qui se trouvent dans l’appel de la fonction.
Une variable globale : est une variable déclarée dans la partie déclaration des variables du
programme principal et utilisable par le programme principal et les sous-programmes.
Une variable locale : est une variable déclarée dans le sous-programme et n'est utilisable qu'à
l'intérieur de ce sous-programme.
4. Application : Ecrire une analyse, un algorithme qui permet de remplir un tableau T de N entiers positifs (3 ≤N ≤6)
et de déterminer la moyenne arithmétique de ce tableau et d’afficher le nombre d’éléments supérieur
à cette moyenne.
L’analyse :
Résultat = Ecrire (NB)
[NB 0] Pour i de 1 à N faire
Si T[i] > M alors NB NB +1
FinSi
FinPour
M FN MOYENNE(T, N)
Pour i de 1 à N Faire
Répéter
T [i]= Donnée (‘’Donner l’élément N°’’, i)
Jusqu'à (T [i]>0)
Fin Pour
Répéter
N= Donnée ('’Donner N'')
Jusqu'à N dans [3..6]
L’Algorithme
0) Début APP1
1) Répéter
Ecrire ('’Donner N''); Lire (N)
Jusqu'à N dans [3..6]
2) Pour i de 1 à N Faire
Répéter
Ecrire (‘’Donner l’élément N°’’, i)
Lire (T [i])
Jusqu'à T [i]>0
Fin Pour
3) M FN MOYENNE (T, N)
4) [NB 0] Pour i de 1 à N faire
Si T[i] > M alors NB NB +1
FinSi
FinPour
4) Ecrire (NB)
5) Fin APP1
Tableau de déclaration des objets globaux
Objet Nature/ Type Rôle
N
i
M
T
MOYENNE
NB
Entier
Entier
Entier
Tableaux de N entiers
Fonction
Entier
Contient la taille du tableau
Le compteur
La moyenne arithmétique du tableau
Contient N entiers positifs
La fonction qui retourne la moyenne du tableau
Le nombre d’élément supérieur à la moyenne
Zinoubi Thameur Lycée 2 Mars 1934 SBZ
L’analyse de la fonction:
DEF FN Maxi (T : Tab, N : entier) : Entier
Résultat = Maxi M
[M T [1]] Pour i de 2 à N Faire
Si (T[i]>=M) alors M T[i]
FinSi
Fin Pour
L’Algorithme de la fonction
0) DEF FN Maxi (T : Tab, N : entier) : Entier
1) [M T [1]] Pour i de 2 à N Faire
Si (T[i]>=M) alors M T[i]
FinSi
Fin Pour
2) Maxi M
3) Fin Maxi
Tableau de déclaration des objets locaux
Objet Nature/ Type Rôle
M Entier Contient l’élément maximum du tableau
Zinoubi Thameur Lycée 2 Mars 1934 SBZ
Leçon N°3 : LES PROCEDURES : 1. Activité :
Ecrire un algorithme qui permet de remplir deux tableaux T1 et T2 de N entiers composés de deux
chiffres avec N compris entre 3 et 6 et de remplir et afficher un 3ème tableau T.
Exemple : Si N = 5
L’algorithme : 0) Début Act1
1) Répéter
Ecrire (‘’Donner N’’) ; Lire (N)
Jusqu'à N dans [3..6]
2) Pour i de 1 à N Faire
Répéter
Ecrire (‘’Donner l’entier N°’’, i) Lire (T1 [i])
Jusqu'à T1 [i] Dans [10..99]
Fin Pour
3) Pour i de 1 à N Faire
Répéter
Ecrire (‘’Donner l’entier N°’’,i) Lire(T2 [i])
Jusqu'à T2 [i] Dans [10..99]
Fin Pour
4) Pour i de 1 à N Faire
T[i]= (T1 [i] Div 10)*1000 + (T1 [i] Mod 10)*10 + (T2 [i] Div 10)* 100+ (T2 [i] Mod
10)
Fin Pour
5) Pour i de 1 à N Faire
Ecrire (T[i])
Fin Pour
6) Fin Act1
Remarques :
Les traitements 2 et 3 permet de remplir deux tableaux pour cela on peut utiliser un seul
module (permet de remplir un tableau de N entiers composé de 2 chiffres) et on l’appelle de
deux manières.
Rendre les 5 blocs 5 appels de 4 modules (fonctions et procédures).
2. Définition :
Une procédure est une suite d’instructions décrivant une action simple ou composée, à laquelle on
affecte un nom, qui peut retourner zéro ou plusieurs résultats. Sa structure est analogue à la
structure d’un algorithme.
3. Syntaxe : Au niveau de l’analyse
DEF PROC Nom_procédure (listes des paramètres : les types)
Résultat = ……..
…………
Au niveau de l’algorithme
0) DEF PROC Nom_procédure (listes des paramètres : les types)
T1 = 12 25 54 99 46
T2 = 54 94 37 59 67
Alors T sera 1524 2954 5347 9599 4667
Zinoubi Thameur Lycée 2 Mars 1934 SBZ
i-1)…………
i) FIN Nom_procédure
Au niveau Traduction en Pascal
PROCEDURE Nom _ procédure (listes des objets : les types);
VAR déclaration des objets locaux;
BEGIN
…………………..
……………………
END ;
Correction de l’activité : L’analyse :
Résultat = Proc Affichage (T, N)
Pour i de 1 à N faire
T[i] FN Fusion (T1,T2,i)
FinPour
Proc Remplissage (T2, N)
Proc Remplissage (T1, N)
Proc Saisir (N)
L’algorithme
0) Début FusionTab
1) Proc Saisir (N)
2) Proc Remplissage (T1, N)
3) Proc Remplissage (T2, N)
4) Pour i de 1 à N faire
T[i] FN Fusion (T1, T2, i)
FinPour
5) Proc Affichage (T, N)
6) Fin FusionTab
Tableau de déclaration des nouveaux types :
Type
Tab=Tableaux de N entiers
Tableau de déclaration des objets globaux :
Objet Nature/ Type Rôle
N
i
T
T1
T2
Saisir
Remplissage
Fusion
Affichage
Entier
Entier
Tab
Tab
Tab
Procédure
Procédure
Fonction
Procédure
La taille des tableaux
Compteur
Tableaux des entiers fusionnés
Le premier Tableau
Le deuxième Tableau
Permet de saisir N
Permet de remplir un tableau
Permet de fusionner deux entiers en un seul
Permet d’afficher un tableau
L’analyse de la procédure Saisir :
DEF PROC Saisir (Var N : entier)
Résultat = N
Répéter
N = Donnée (‘’Donner N’’)
Jusqu'à N dans [3..6]
L’algorithme de la procédure Saisir :
0) DEF PROC Saisir (Var N : entier)
1) Répéter
Ecrire (‘’Donner N’’) ; Lire (N)
Jusqu'à N dans [3..6]
2) Fin Saisir
L’analyse de la procédure Remplissage :
DEF PROC Remplissage (Var T : tab ; N : entier)
Résultat = T
Pour i de 1 à N Faire
Répéter
T [i]= Donnée ('' Donner l’élément N°'', i),
Jusqu'à (T [i] dans [10..99])
Fin Pour
L’algorithme de la procédure Remplissage:
0) DEF PROC Remplissage (Var T : tab ; N : entier)
1) Pour i de 1 à N Faire
Répéter
Ecrire ('' Donner l’élément N°'', i), Lire (T[i])
Jusqu'à (T[i] dans [10..99])
Fin Pour
2) FIN Remplissage
L’analyse de la fonction Fusion :
DEF FN Fusion (T1, T2 : tab ; i : entier) : entier
Résultat = Fusion X
X (T1[i] Div 10)*1000 + (T1[i] Mod 10)*10 + (T2[i] Div 10)*100 + (T2[i] Mod 10)
L’Algorithme de la fonction:
0) DEF FN Fusion (T1, T2 : tab ; i : entier) : entier
1) X (T1[i] Div 10)*1000 + (T1[i] Mod 10)*10 + (T2[i] Div 10)*100 + (T2[i] Mod 10)
2) Fusion X
3) Fin Fusion
Tableau de déclaration des objets locaux
L’analyse de la procédure Affichage :
DEF PROC Affichage (T : tab ; N : entier)
Résultat = T
Pour i de 1 à N Faire
Ecrire (T[i]),
Fin Pour
L’algorithme de la procédure Affichage:
0) DEF PROC Affichage (T : tab ; N : entier)
1) Pour i de 1 à N Faire
Ecrire (T[i])
Fin Pour
2) FIN Remplissage
Traduction Turbo Pascal:
Program FusionTab;
Uses wincrt;
Type TAB = array [1.. 6] of integer;
Var T, T1, T2: TAB;
i, N: integer;
{Cette procédure permet de saisir un entier N }
Objet Nature/ Type Rôle
X Entier L’entier fusionné
L‘appel de la fonction
L‘appel de la fonction
Procedure Saisir (Var N: integer);
Begin
Repeat
Writeln(' Donner N'); readln(N);
Until (N in [3 .. 6]);
End;
{Cette procédure permet de remplir un tableau de N entiers}
Procedure Remplissage (Var T : TAB; N:integer);
Begin
For i:= 1 to N do
Repeat
Writeln (' Donner l''élément N°', i); readln (T[i]);
Until (T[i] in [10 .. 99]);
End;
{Cette fonction permet de fusionner deux entiers en un seul entier}
Function Fusion (T1, T2: tab; i: integer): integer;
Var X : integer ;
Begin
X: = (T1 [i] Div 10)*1000 + (T1 [i] Mod 10)*10 + (T2 [i] Div 10)*100 + (T2 [i] Mod 10);
Fusion: = X;
End ;
Begin
Saisir (N);
Remplissage (T1, N);
Remplissage (T2, N);
For i: = 1 to N do
T[i]:= Fusion (T1, T2, i);
Affichage (T, N);
End.
Remarques :
La déclaration d'une Procédure ou fonction en Pascal se trouve après la déclaration des variables
globales.
L’appel de la procédure dans le programme principale comme suit : Remplissage (T1, N)
Les paramètres effectifs et les paramètres formels doivent s’accorder du point de vue nombre et ordre
et leurs types doivent être identiques ou compatibles.
4. Le passage de paramètres: C’est l’échange des paramètres formels et effectifs entre le programme appelant et la procédure appelé.
Dans la déclaration de la procédure on a : DEF PROC Remplissage (Var T : tableau ; N : entier)
Les paramètres formels sont N et T, Mais ils ont deux modes de passage :
Passage de paramètre par valeur pour N.
Passage de paramètre par variable pour T.
Si le paramètre formel est précédé par le mot VAR, le mode du passage du paramètre effectif correspondant
est par variable, Sinon ce mode est par valeur.
a) Passage de paramètre par valeur :
Le programme appelant transmet des valeurs à la procédure appelée. Toute modification du paramètre
formel est sans conséquent sur la valeur du paramètre effectif. Si la valeur de N change dans la procédure
cette modification n’est pas transmet au programme appelant.
Programme Appelant Procédure appelé
N N
b) Passage de paramètre par variable :
Le programme appelant transmet des valeurs à la procédure appelée. Toute modification du paramètre
formel est transmet au paramètre effectif. Si les valeurs de T changent dans la procédure ces modifications
sont transmet au programme appelant.
Programme Appelant Procédure
T T
Toute modification du paramètre formel, entraîne automatiquement la modification de la valeur du
paramètre effectif.
Top Related