Module : Pascal Chapitre 02 : analyse et décomposition

INSTITUT D’INFORMATIQUE ET TECHNIQUES DE GESTION

Agrément N ° 896/04 du 24 Novembre 2004

Module : Pascal

Chapitre 022 : Analyse et décomposition

Semestre 2

Année : 2013/2014
-1-
Module : Pascal Chapitre 02 : analyse et décomposition

SOMMAIRE

Chapitre VI : Analyse et décomposition d’un problème

1. Introduction
2. Les Procédures
2.1. Déclarations
2.2. Construction de procédure
2.3. Appel d’une procédure
2.4. Procédures paramétrées
2.5. Variables locales et globales

3. Les Fonctions
3.1. Déclarations
3.2. Construction de procédure
3.3. Appel d’une procédure
3.4. Procédures paramétrées
3.5. Variables locales et globales
4. La récursivité
5. Résumé
6. QCM
7. Exercices
8. Bibliographie

-2-
Module : Pascal Chapitre 02 : analyse et décomposition

Chapitre 2 : Analyse et décomposition d’un problème

1. Introduction

La programmation modulaire est une technique utilisée pour écrire de longs

programmes. Le programme est divisé en petites parties. Chaque partie est
appelée module et exécute une tâche simple.

Exemple de tâche qu'un module peut réaliser:

• affichage d'un menu d'option

• affichage des résultats
• calcul d'une moyenne de résultats
• tri de données selon des groupes

Un module est connu par son nom et consiste en un ensemble d'instructions

regroupées par les mots-clés begin et end. Le module (ensemble d'instructions)
est exécuté lorsque le nom du module est rencontré.

Pascal possède deux types de modules appelés respectivement PROCEDURE

(procédure) et FUNCTION (fonction).

• Les procédures non paramétrées n'acceptent aucun arguments lors de leur

exécution (appel).
• Les procédures paramétrées acceptent des arguments qu'elles utilisent lors de
l'exécution.
• Les fonctions, lorsqu'elles sont exécutées, renvoient une valeur (c'est-à-dire,
fournissent une réponse qui est transmise au module appelant). Comme les
procédures, elles peuvent accepter des arguments.

Les procédures aident à structurer les programmes, en permettant le

développement indépendant des modules. Les procédures sont essentiellement
des sous-programmes.
2. Les Procédures
Vous avez déjà été amené à utiliser des "fonctions prédefinies" telles que
sqr,sqrt... Vous avez pu constater que cette notion de fonction en Pascal est
très proche de la notion mathématique classique.
En particulier, une fonction possède généralement un ou plusieurs arguments
et elle fournit un résultat. Quant à l'aspect modulaire, on peut dire que le fait
de mentionner le nom d'une fonction
dans un programme entraîne l’appel de tout un ensemble d'instructions
(module) en réalisant le calcul.
La procédure, quant à elle, n'est rien d'autre qu'une généralisation de la
notion de fonction. Elle peut, elle aussi, posséder des arguments; en
revanche, elle peut, en retour, fournir un ou plusieurs résultats, ou même
aucun. Mais ces résultats (lorsqu'ils existent) ne constituent pas
nécessairement le seul "travail" de la procédure; par exemple, cette dernière
peut imprimer un message. On peut dire de la procédure qu'elle réalise une
"action", terme plus général que calcul. Notez que nous avons déjà été
amené à utiliser des procédures ''prédefinies'' pour les entrées-sorties (read,
write) et pour les manipulations de chaînes.

-3-
Module : Pascal Chapitre 02 : analyse et décomposition

En ce qui concerne la notion d'argument, nous verrons que celle-ci est plus
générale qu'en mathématiques; en particulier, elle interfère avec les notions
de "variables globales et locales". C'est pourquoi, nous allons commencer par
vous présenter une succession d'exemples introduisant progressivement les
notions fondamentales (variables globales, variables locales, arguments
muets et effectifs, arguments transmis par valeur, arguments transmis par
adresse). Nous parlerons des procédures en premier, les fonctions
apparaissant ensuite comme un cas particulier.

Exemple :
program LOCAL_VARIABLES (input, output);
var number1, number2 : integer; {elles sont toujours accessibles}

procedure add_numbers;
var result : integer; {result appartient à add_numbers}
begin
result := number1 + number2;
writeln('La réponse est ',result)
end;

begin {le programme commence ici}

writeln('Entrez deux nombres à additionner');
readln( number1, number2 );
add_numbers
end.
Déclarations
Syntaxe :
Procedure nom_procedure (liste param)
Partie declaration
Begin
Partie
program Exemple procedure_1 ;
instruction
var i : integer ;
End ;
procedure pessimist ; {sans paramètres}
Exemple : begin
writeln ('il ne fait jamais beau')
15
end ;
begin for i := 1 to 5 do pessimist ;
writeln ('du moins, on le croit')
end.

program elec;

var MonResultat : Real;

procedure LoiOhm(I, U, R : Real); {avec paramètres}

begin
R := U / I;
end;

begin
writeln('Avant -> MonResultat = ', MonResultat); { Sortie -> 0 }
LoiOhm(15, 250, MonResultat); -4- { On passe notre
variable en argument}
writeln('Après -> MonResultat = ', MonResultat); { Sortie -> 0 }
end.
Module : Pascal Chapitre 02 : analyse et décomposition

Construction de procédure
Pour construire une procédure il faut agir comme suite :
1. Identifiez un bloc d’instruction dans l’exécution peut se répéter à plusieurs
reprise
2. Identifiez les données qui peuvent changée à chaque fois ou le bloc sera
exécuté
3. Le bloc instruction sera alors insérer dans une procédure dans nom est
proche de l’action réalise par le bloc , les données qui changent sont
remplacés par des paramètre appelée paramètre données
4. Si un résultat explicite doit être récupéré après la fin du bloc, ce résultat doit
être représenté par paramètre appel paramètre résultat
5. à chaque fois ou le bloc doit être exécuté on fait appel au procedure on
indiquant son nom et ses paramètres réels

Appel d’une procédure

L’appel d’une procédure permet d’exécuter les instructions qu’elle contient, et cela
se fait par son nom.
Exemple :

program Nombres;
(* déclaration des variables *)
var A, B : integer;
var C : integer;

(* définition de la procédure *)
procedure Ordonne; (* toujours pas d'arguments pour la
procédure *)
var C : integer; (* variable locale à la procédure *)
begin
if (A > B) then
(* on ordonne les variables dans un ordre croissant
*)
begin
C := A;
A := B;
B := C;
end;
end;

(**** début du programme principal ****)

begin
(* entrées *)
write('Entrez deux nombres entiers : ');
readln(A,B);
C := chr(225);

(* traitement *)
Ordonne; // appel de la procedure

(* sorties *)
writeln; (* ligne vide *)
write('Vos nombres par ordre croissant : ');
writeln(A, ' ', B);
writeln; (* ligne vide *)
writeln('Variable C : ', C);
end. -5-
Module : Pascal Chapitre 02 : analyse et décomposition

Procédures paramétrées

Les échanges d'informations entre une routine(programme ou sous programme) appelant une
sous-routine peuvent se faire par l'intermédiaire des variables globales. Mais il est beaucoup
plus intéressant d'utiliser les PARAMETRES (arguments), donc les paramètres représentent
les point d’entrée pour un procédure ou fonction, permettant de fournir des données et dans
autres cas récupérer les résultats d’une procédure .

Dans le cas ou les paramètres fouinssent les données on les appels paramètre donnée, dans
l’autre cas on les appels paramètres résultats.

On à deux type de paramètres :

Paramètres formels : sont ceux qui figure dans la définition d’une procédure

Paramètres réel : sont ceux qui figurent dans les appels d’une procédure ;

On appel passage de paramètres la correspondance en les paramètre réels et paramètres

formels lors de l’appel.

Selon le type des paramètres (données ou résultats) on a deux type de passages :

Passage par adresse :( le paramètre formel reçoit une copie de la valeur du paramètre
réel),dans le cas d’un paramètre donné,

Passage par valeur : ( le paramètre formel reçoit une copie de l’adresse du paramètre réel)

Exemple : procédure avec paramètres donnés

PROGRAM machin (input,output);

VAR a,b,c,d:real;
PROCEDURE aff_somme(x,y:real); {paramètres données}
var z:real;
begin
z:=x+y;
writeln(x ,' + ', y ,' = ', z)
end;
BEGIN {programme principal}
writeln('entrez 4 valeurs : ');
readln(a,b,c,d);
aff_somme(a,b); aff_somme(3,5); aff_somme(c+a,d)
END.

En appelant AFF_SOMME(A,B), la procédure prend pour X la valeur de A, et pour Y la valeur

de B. On dit que les arguments sont "passés par valeur". Mais si la procédure modifiait X ou Y,
A et B ne seraient pas modifiés dans le programme appelant. Pour répercuter les
modifications des arguments, il faut les déclarer comme "variables" (ils sont alors dits "passés
par adresse").
-6-
Module : Pascal Chapitre 02 : analyse et décomposition

Exmple02: procédure avec paramètres résultats

procedure echange(VAR x,y:real);{paramètres résultats}
var z:real;
begin
z:=x;
x:=y;
y:=z
end; {cette procédure échange les contenus des 2
arguments}

Variables locales et globales

Variables locales : sont les variables déclarées dans une procédure, ces variable ne
sont visible que dans le corps de procédure et non connues dans les autre partie du
programme.
Variables Globales : sont les variables déclarées dans le programme principale, ces
variables sont visible dans tous le programme et tous les procédure rattachés, sauf
dans les sous programme ou il existe une variable locale portant le même nom, dans ce
cas on dit que la variable locale masque la variable globale dans cette procédure.

Exemple :

program Exemple procedure_2;

var I,K :integer ;{variable Globale, K est masque dans la
procedure Optimist}
procedure optimist;
var J,L,K {variable Locales}
begin
writeln ('il ne fait jamais beau');
writeln (‘---- , i, ‘fois';
end;
begin
for i := 1 to 5 do
optimist ;
writeln ('du moins, on le croit’)
3. L end .
e
s Fonctions
Tout ce qui a été dit pour les procédures s'applique également aux fonctions. La
différence avec une procédure est qu'une fonction renvoie un résultat. L'entête est
du type :

FUNCTION nom_fonction (liste_parametres):type_de_la_fonction

la liste des paramètres (en général passés par valeur) est de la même forme que pour une
procédure, le type de la fonction étant le type du résultat retourné. On retourne le résultat par :

NOM_FONCTION := ... Cette affectation ne peut se faire qu'une seule fois par appel à la
fonction.

-7-
Module : Pascal Chapitre 02 : analyse et décomposition

ex : La fonction MAX a 2 paramètres réels (X et Y) et renvoie un réel.

Utilisation de fonctions
On utilise une fonction dans le cas ou on a besoins d’une valeur
résultante d’une suite d’instruction, et cette valeur doit être utilisé dans une
expression arithmétique.
Fonctions prédéfinies
Program classer (input,output);
var a,b,c:real;
function MAX(x,y:real):real;
begin
if x>=y then MAX:=x else MAX:=y
end;
begin
writeln('entrez deux valeurs : ');
readln(a,b);
c:=max(a,b);
writeln('le plus grand est ',c)
end.

Plusieurs fonctions sont prédéfinies en pascal, et peuvent être utilisées

par simple appel, en fournissant les arguments nécessaires.
Exemple : Cos, Sin, Sqr(x) Carré), Sqrt(x) racine carré,…
Remarque : consulter l’aide du turbo-pascal pour avoir une aidé claire
sur tous les fonctions prédéfinies.

Appel de fonction en pascal

On peut appeler une fonction comme une procédure sauf on a la
possibilité que cet appel peut se faire dans une affectation on une
expression ;
Exemple :

program classer(input,output);
var a,b,c:real;
function MAX(x,y:real):real;
begin
if x>=y then MAX:=x else MAX:=y
end;
begin
writeln('entrez deux valeurs : ');
readln(a,b);
c:=max(a,b); {appel dans une affectation}
C :=max(c,max(b,10) ; {appel dans une affectation, et expression}
writeln('le plus grand est ',c)
end.

Fonctions paramétrées
Le même principe que les procédures

-8-
Module : Pascal Chapitre 02 : analyse et décomposition

Variables locales et globales

Le même principe que les procédures

4. La récursivité

C'est ainsi que l'on appelle le fait qu'une routine puisse s'appeler elle-
même

function factorielle(n:integer):integer;
begin
if n<=1 then factorielle:=1
else factorielle:=n*factorielle(n-1)
end;

Par exemple en appelant factorielle(3), on calcule 3*factorielle(2). Or

factorielle(2)=2*factorielle(1), qui lui vaut 1. Donc factorielle(3)=3*(2*1) (ce qui
me parait juste). Faites un petit dessin, à chaque appel on recrée de
nouvelles variables locales, donc on obtient 3 cases N distinctes valant 3, 2 et
1, on les supprime petit à petit en passant sur le END.
Rq : Il faut toujours vérifier qu'en aucun cas on ne puisse avoir une
boucle infinie qui bloquerait la machine. Ce serait le cas en mettant le test IF
N=1 et en appelant factorielle pour une valeur négative ou nulle.
Une procédure devant toujours être déclarée pour pouvoir être utilisée,
on utilise FORWARD pour les cas de récursivité passant par 2 procédures :

function prem(a,b:real):boolean; FORWARD;

{déclaration anticipée de l'entête }
procedure deux(x,y:real);
var bool:boolean;
begin
......
bool:=prem(x,y); {on peut utiliser PREM car déjà déclarée}
......
end;
function prem;
{ne plus donner les arguments car déjà déclarés}
begin
......
if pas_fini then deux(a,b); (* DEUX déjà déclarée*)
......
end;

-9-
Module : Pascal Chapitre 02 : analyse et décomposition

5. Résumé

Les sous programmes en pascal permettent de construire des programmes

longs, et compliqués.
Les sous programme en pascal sont deux types : procédures, et fonctions.
La procédure est un sous programme ne retournant pas de résultat explicite.
La fonction c’est sous programme retournant un résultat explicite
Les procédures et les fonctions en pascal peuvent être avec ou sans
paramètres.
Un paramètre peut être formel ou réel.
Une fonction qui fait appel à elle-même est appelée fonction récursive.
Les fonctions récursives permettent de résoudre des problèmes qui ont caractère
spécial.
En pascal il y a des fonctions prédéfini qui peuvent être utilisé directement par le
programmeur Ex : Cos(x), sin(x), Sqr(x)

-10-
Module : Pascal Chapitre 02 : analyse et décomposition

6. QCM

1. la déclaration des procédures et fonctions se fait juste avant Begin du

programme principale.[Vrai,Faux]
2. la procédure peut toujours remplacer la fonction.[Vrai,Faux]
3. on peut faire l’appel d’une procédure dans une expression.[Vrai,Faux]
4. une procédure peut être récursive.[Vrai,Faux]
5. une fonction et une procédure. .[Vrai,Faux]
6. une procédure et un sous programme .[Vrai,Faux]
7. Paramètres formels : sont ceux qui figure dans la définition d’une
procédure.[Vrai,Faux]
8. On appel une fonction dans le programme principale le sous
programme.[Vrai,Faux]
9. Les fonctions peuvent être sans paramètre dans toute les langage [Vrai,Faux].
10. La procédure est un sous programme ne retournant pas de résultat [Vrai,Faux].

-11-
Module : Pascal Chapitre 02 : analyse et décomposition

7. Exercices

Exercices 1:TP

1) Écrire une procédure permettant de déterminer si un nombre est premier.

Elle comportera deux arguments : le nombre à examiner, un indicateur
booléen précisant si ce nombre est premier ou non.

Exercices 2:

2) Écrire la procédure précédente sous forme de fonction.(facultatif)

Exercices 3:TP
3) Écrire une fonction calculant la norme d’un vecteur à 3 composantes
réelles.

Exercices 4:
4) Écrire la fonction précédente sous forme d’une procédure.

Exercices 5:TP
5) Écrire une procédure supprimant tous les espaces d’une chaîne de
longueur maximale de 50 caractères

Exercices 6:TP
6) Écrire une fonction calculant le produit vectoriel de deux vecteurs à 3
composantes réelles.

Exercices 7:
7) Écrire une procédure simulant le lancé d’un dé à six faces.(facultatif)

Exercices 8:

8) Écrire un programme du jeu de 421 auquel joue deux joueurs en utilisant

un maximum de procédures ou fonctions.

-12-
Module : Pascal Chapitre 02 : analyse et décomposition

8. Bibliographie

• Introduction au pascal P. le beux Sybex

• Turbo pascal (le manuel de l’utilisateur) Borland
• Turbo pascal (le manuel de référence) Borland

SITES WEB :

• www.developpez.com
• www.commentçamarche.com
• www.codesource.com
• www.emagister.fr

-13-