Les sous programmes

(1)

Les sous

programmes

I. INTRODUCTION

Un programme devient très rapidement complexe dès que le nombre de traitements augmente. Il devient alors judicieux de le décomposer en plusieurs modules distincts (sous programmes) et de n’indiquer dans le programme principal que la description de l’enchaînement de ces sous programmes.

I. LES FONCTIONS

1. D

^ÉFINITION

Une fonction est tout simplement un sous programme qui retourne une seule valeur d’un seul type simple (entier, réel, caractère, booléen ou chaîne) qui sera celui de la fonction.

2. D

^ÉCLARATION

En algorithmique En Pascal

DEF FN Nom_Fonction ( Liste des paramètres formels ) : type du résultat

Début

Instructions de la fonction Nom_Fonction  résultat Fin NomFonction

Function NomFonction ( Liste des paramètres formels ) : type du résultat ;

{ Déclarations locales } ; Begin

Instructions de la fonction ; Nom_Fonction := résultat ; End ;

3. A

^PPLICATION

Ecrire un programme qui calcule la puissance de deux entiers x et y.

a. Analyse

Analyse de la fonction POWER

DEF FN POWER ( x : entier ; y :entier) : entier Résultat = P

Traitement : [ P  1 ]

Pour i de 1 à y faire P  P * x

Fin pour Power  P

 Prof : Soussi Ezzeddine Page 1

(2)

Analyse du programme principal

Résultat = Ecrire (x, " à la puissance ", y, " = ", Power(x,y)) Données = X=donnée (" Donner x ")

Y=donnée (" Donner y ")

b. Algorithmes

Algorithme de la fonction power

0) DEF FN POWER(x :entier ; y :entier) : entier 1) P  1

2) Pour i de 1 à y faire P  P * x

3) Power  P 4) Fin power

Algorithme du programme principal 0) Début Puissance

1) Ecrire (" Donner x ") Lire(x) 2) Ecrire (" Donner y ") Lire(y)

3) Ecrire(x, " puissance ",y, " = ",power(x,y)) 4) Fin Puissance

Tableau de déclaration des objets

Objet Type / Nature Rôle

P i Power

X,y

Entier Entier Fonction

Entier

Puissance à calculer Compteur

Fonction calcul puissance Entiers donnés

c. Programme Pascal program powerxy;

uses wincrt;

var

x,y:integer;

function power( x : integer ; y : integer): integer;

var

i: integer;

p: integer;

begin p := 1;

for i := 1 to y do p := p * x;

power := p;

end;

(3)

begin

writeln('donner x');

readln(x);

writeln('donner y');

readln(y);

writeln(x,' Puissance ',y,' = ',power(x,y));

end.

4. R

^EMARQUES

 Les paramètres formels d’une fonction sont toujours passés par valeur.

 Le type de résultat retourné par une fonction doit être simple (le type tableau n’est pas permis).

 Une fonction appelée est manipulée comme une valeur.

Exemple : X := X + Somme(5, 6) ;

 Il est nécessaire d’affecter le résultat du calcul de la fonction au nom de la fonction, obligatoirement avant la fin du bloc.

II. LES PROCEDURES

1. D

ÉFINITION

Les procédures sont des sous programmes qui peuvent avoir plusieurs résultats.

2. D

^ÉCLARATION

En turbo Pascal, la déclaration d’une procédure figure après la déclaration des variables globales. Une procédure peut également contenir des déclarations locales.

L’entête d’une procédure est composé du nom de la procédure suivi d’un ensemble de paramètres. On désigne pour chaque paramètre le type et le mode de passage.

Remarque : Une procédure peut être non paramétrée.

En algorithmique En Pascal

DEF PROC NomProcédure (Paramètres formels)

DEBUT

Instructions de la procédure FIN NomProcédure

Procedure NomProcédure (Paramètres formels) ;

VAR { Déclarations locales } ; Begin

Instructions de la procédure ; End ;

3. A

PPLICATION

Soit à saisir n caractères dans un tableau T de taille Max =100, puis de créer à partir de T, 3 tableaux (TL : tableau de lettres, TS : tableau de symboles, TC : tableau de chiffres) et enfin afficher le contenu des trois tableaux.

(4)

3.1. Décomposer ce problème en modules :

La résolution de ce problème passe par les étapes suivantes :

 Saisie de la taille réelle du tableau T (au niveau du programme principal).

 Saisie des éléments du tableau T (au niveau du programme principal).

 Création des trois tableaux TL, TS et TC ( les procédures créer_TL, Créer_TC et Créer_TS ).

 Affichage des contenus des tableaux résultats (la procédure Affichage).

D’où la grille du programme principal suivant :

Analyse :

Résultat = (PROC Affiche (TC,C), PROC Affiche (TS,S), PROC Affiche(TL,L)) Traitement : (TC,C) = PROC Créer_TC (T, n, TC, C)

(TS,S) = PROC Créer_TS (T, n, TS, S) (TL,L) = PROC Créer_TL (T, n, TL, L) Données =

T = Pour i DE 1 A n Faire

T [i] = Donnée("t[",i, "]= ") Fin Pour

N = Répéter

n = Donnée("Donner la taille du tableau") Jusqu’à n dans [1 .. 100]

3.2. Analyser chaque module :

a. La procédure Créer_TL

DEF PROC Créer_TL (T : TAB ; n : Entier ; Var TL : TAB ; Var L : Entier) Résultat = Tableau de lettres

Traitement : [ L  0 ] Pour i De 1 A n Faire

Si Majus (T[i]) Dans ["A".."Z"] Alors L  L + 1

TL[ L ]  T[ i ] FinSi

FinPour b. La procédure Créer_TS

DEF PROC Créer_TS (T : TAB ; n : Entier ; Var TS : TAB ; Var S : Entier) Résultat = Tableau de Symboles

Traitement : [ S  0 ] Pour i De 1 A n Faire

Si NON(Majus (T[ i ]) Dans ["A".."Z","0" .. "9" ]) Alors S  S + 1

TS[ S ]  T[ i ] FinSi

FinPour c. La procédure Créer_TC

(5)

DEF PROC Créer_TC (T : TAB ; n : Entier ; Var TC : TAB ; Var C : Entier) Résultat = Tableau de Chiffres

Traitement : [ C  0 ] Pour i De 1 A n Faire

Si T[ i ] Dans ["0".. "9"] Alors C  C + 1

TC[ C ]  T[ i ] FinSi

FinPour d. La procédure Affiche

DEF PROC Affiche ( Tx : TAB ; x : entier ) Résultat = Affichage

Traitement : Pour i De 1 A x Faire

ecrire ( Tx [ i ], " " ) Finpour

3.3. Attribuer à chaque grille un algorithme :

a. Procédure Créer_TL

0 ) DEF PROC Créer_TL ( T : TAB ; n : Entier ; VAR TL :TAB ; VAR L : Entier ) 1 ) L  0

Pour i De 1 A n faire

Si Majus ( T[ i ] Dans ["A".."Z"] Alors L  L + 1 TL[ L ]  T[ i ] FinSi

FinPour 2 ) Fin Créer_TL

b. Procédure Créer_TS

0 ) DEF PROC Créer_TS ( T : TAB ; n : Entier ; Var TS : TAB ; Var S : Entier ) 1 ) S  0

Pour i De 1 A n Faire

Si NON(Majus (T[ i ]) Dans ["A".."Z","0" .. "9" ]) Alors S  S + 1

TS[ S ]  T[ i ] FinSi

FinPour 2 ) Fin Créer_TS

c. Procédure Créer_TC

0 ) DEF PROC Créer_TC ( T : TAB ; n : Entier ; Var TC : TAB ; Var C : Entier ) 1 ) C  0

Pour i De 1 A n faire

Si T[ i ] Dans ["0".."9" ] Alors C  C + 1 TC[ C ]  T[ i ]

(6)

FinSi FinPour

2 ) Fin Créer_TC

d. Procédure Affiche

0) DEF PROC Affiche (Tx : TAB ; x : entier ) 1) Pour i de 1 à x faire ecrire ( Tx [ i ], " " )

2) Fin Affiche

e. Programme principal 0 ) Début ECLAT

1 ) Répéter

Ecrire("donner la taille du tableau ") , lire(n) Jusqu’à n dans [1 .. 100]

2 ) Pour i DE 1 A n Faire

Ecrire("t[",i, "]= ") , lire(t[i]) Fin Pour

3 ) Créer_TC ( T, n , TC , C ) 4 ) Créer_TS ( T, n , TS , S ) 5 ) Créer_TL ( T, n , TL , L ) 6 ) Affiche ( TC , C )

Affiche ( TS , S ) Affiche ( TL , L ) 7 ) Fin ECLAT

Tableau de déclaration des nouveaux types

Types

TAB = TABLEAU de 100 caractères

Tableau de déclaration des objets

Objet Type / Nature Rôle

Affiche TC, TS, TL

C, S, L

Créer_TC, Créer_TS, Créer_TL T

n i

Procédure TAB Entier Procédure

TAB Entier entier

Affichage de tableaux Tableau résultats

Compteur des tableau résultats Procédures de création des tab

Tableau donné Taille de T

compteur

f. Remarques

 Les procédures Créer_TL, Créer_TS, Créer_TC et Affiche sont des sous- programmes appelés.

 Le programme Eclat est appelé appelant.

(7)

4. T

YPES D

’

OBJETS

Tous les objets (constantes, types, variables et sous-programmes) déclarés dans un sous – programme sont dits locaux à celui – ci.

Exemple : le compteur i

Les objets utilisés dans un sous – programme et non déclarés dans celui – ci sont des objets globaux déclarés dans le programme appelant.

Exemple : la variable n est une variable globale par rapport à la procédure Créer_TL (n est déclaré au niveau du programme principal (appelant) ECLAT ).

5. A

^PPEL ^D

’

^UNE ^PROCÉDURE

D’une façon générale, l’appel d’une procédure se fait par le biais de son nom procéder par l’expression PROC et suivi de la liste des paramètres effectifs (sans leurs types) s’ils existent.

Cela permet d’exécuter les instructions au sein de cette procédure : Nom-Procédure ( paramètres effectifs ) ;

ou bien

Nom-Procédure ; { procédure sans paramètres }

6. T

^YPES ^DE ^PARAMÈTRES

Il existe deux types de paramètres :

 Les paramètres formels se trouvant au niveau de l’entête de sous programme et

 Les paramètres effectifs figurant au niveau de l’appel de sous - programme.

Les paramètres effectifs et les paramètres formels doivent s’accorder de point de vue nombre, ordre et type.

Exemple : DEF PROC affiche ( Tx : TAB ; x : Entier ) PROC Affiche ( TL , L )

7. P

^ASSAGE ^DE ^PARAMÈTRES

La substitution des paramètres effectifs aux paramètres formels s’appelle passage des paramètres, elle correspond à un transfert de données entre le programme appelant et la procédure ou l’inverse. Ce passage peut se faire par valeur ou par variable.

7.1. Passage par valeur

Les paramètres passées par variables sont précédés par VAR. Exemple, pour la procédure Créer_TL ( T : TAB ; n : Entier ; VAR TL : TAB ; VAR L : Entier ), L et TL sont passés par variable.

Le passage de paramètres par valeur permet au programme appelant de transmettre une valeur au sous – programme appélé.

Programme appelant Programme appelé

(8)

7.2. Passage par variable

Le passage de paramètres par variable permet au programme appelant de transmettre une valeur au sous – programme et vice versa.

7.3. Exemple

ECLAT PROC Créer_TL(T :TAB ; n : Entier ; VAR TL :TAB ; VAR L :Entier)

T , n T et n n’ont subit aucun changement

TL vide

TL TL était modifié ( rempli )

TL rempli

Non déterminé

L L était modifié

Taille de TL

8. D

^ISPOSITION ^DES DIFFÉRENTES PARTIES DU PROGRAMME EN

T

^URBO

P

^ASCAL

Program ECLAT ; uses wincrt;

TYPE

TAB = Array [ 1..100 ]of char ; Var

T, TL, TS, TC : TAB ; L, S, C, n, j : Integer ;

{ Déclaration de la procédure Créer_TL }

Procedure Creer_TL ( T : TAB ; n : integer ; VAR TL :TAB ; VAR L : integer );

Var

i : Integer ; begin L := 0 ;

For i := 1 To n Do

If Upcase (T[ i ] ) In ['A'..'Z'] Then Begin

L := L + 1;

TL[ L ] := T[ i ] ; End ;

End ;

{ Déclaration de la procédure Créer_TS }

Programme appelant Programme appelé

(9)

Procedure Creer_TS ( T : TAB ; n : integer ; VAR TS :TAB ; VAR S : integer );

Var

i : Integer ; begin S := 0 ;

For i := 1 To n Do

If NOT ( Upcase (T[ i ] ) In ['A'..'Z','0'..'9'] ) Then Begin

S := S + 1;

TS[ S ] := T[ i ] ; End ;

End ;

{ Déclaration de la procédure Créer_TC }

Procedure Creer_TC ( T : TAB ; n : integer ; VAR TC :TAB ; VAR C : integer );

Var

i : Integer ; begin C := 0 ;

For i := 1 To n Do If T[ i ] In ['0'..'9'] Then Begin

C := C + 1;

TC[ C ] := T[ i ] ; End ;

End ;

{ Déclaration de la procédure Affiche }

Procedure Affiche (var Tx : TAB ;var x : Integer );

Var

i: Integer ; Begin

For i := 1 To x Do

Writeln ( Tx [ i ], ' ');

End;

{Programme principal}

Begin

Repeat

writeln('donner la taille du tableau');

Readln ( n ) ;

Until n In [ 1 .. 100 ] ; For j:=1 To n Do begin

writeln('T[',j,']= ');

Readln ( T [ j ] ) ; end;

Creer_TC ( T, n , TC , C ) ; Creer_TS ( T, n , TS , S ) ; Creer_TL ( T, n , TL , L ) ;

(10)

Affiche ( TC , C ) ; Affiche ( TS , S ) ; Affiche ( TL , L ) ; End.