Chapitre 4 : Les sous-programmes

4.1. Introduction

Le but de l’utilisation de sous programmes :

 Décomposition des problèmes en modules (sous problèmes de taille réduite) :

o Dans un programme plusieurs séquences d’instructions sont appelées plusieurs

fois et depuis divers points du programme. Il serait donc plus intéressant
d’isoler ces séquences dans un sous-programme qui peut être appelé depuis
n’importe quel point du programme.
o L’approche modulaire réduit énormément le nombre d’instructions
redondantes (qui se répètent) moyennant l’ajout d’une séquence d’appel pour
le module à différents endroits du programme. D’où la réduction de la taille du
programme.
o La lisibilité qui facilite notablement la compréhension du programme

 Réutilisation du sous-programme

En résumé, le programme sera plus lisible et plus facile à maintenir (à modifier éventuellement
par la suite).
Un sous-programme est une portion de code analogue à un programme, déclaré dans un
programme ou dans un sous-programme et dont la partie instruction peut être exécutée plusieurs
fois au cours du traitement du programme grâce à des appels. On distingue deux formes de sous
programmes : Les procédures et les fonctions.

4.2. Les procédures

Une procédure est un sous-programme qui effectue un traitement (suite d’instructions). Les
procédures sont utilisées pour éviter d’avoir à réécrire plusieurs fois une même suite
d’instructions figurant plusieurs fois dans le programme.

a) Les procédures sans paramètre

Syntaxe :

Procédure nom_procédure ;
//partie des déclarations
Début
Suite d’instructions ;
FinProcédure ;

Appel (utilisation) :

nom_procédure ;

Exemple

Algorithme Principal ;
Var nom, prenom : chaine de caractères ;
21

Algorithmique –ENSP - Humanité numérique & Art numérique Ingénieur – Mme NINKO Lidwine
 age : entier ;
Procédure Banniere ;
Début
Ecrire (‘’Bonjour, attention vous êtes dans sur une plateforme privée’’) ;
Ecrire (‘’Veuillez-vous identifier‘’) ;
FinProcédure ;
Début
Banniere ;
Ecrire (‘’Entrer vos noms et prénoms‘’) ;
Lire (nom, prenom) ;
Ecrire (‘’Entrer votre âge ‘’) ;
Lire (age) ;
Fin

b) Les procédures avec paramètres

b.1. Syntaxe :

Procédure nom_procédure (<liste des paramètres>) ;

//partie des déclarations
Début
Suite d’instructions ;
FinProcédure ;

b.2. Appel (utilisation) :

nom_procédure (<liste des paramètres>) ;

Exemple

Algorithme Principal ;
Var x, y : entier ;
Procédure Permute (var u,v : entier) ;
Var z : entier ;
Début
z u ;
uv ;
vz ;
FinProcédure ;
Début
Ecrire (‘’Entrer les valeurs de x et y‘’) ;
Lire (x,y) ;
Permute(x,y) ;
Ecrire (‘’Les valeurs de x et y après permutation sont : ‘’, x, y) ;
Ecrire (‘’Entrer les nouvelles valeurs de x et y‘’) ;
Lire (x,y) ;
Permute(x,y) ;
Ecrire (‘’Les valeurs de x et y après permutation sont : ‘’, x, y) ;
Fin

22

Algorithmique –ENSP - Humanité numérique & Art numérique Ingénieur – Mme NINKO Lidwine
 b.3. Passage de paramètres

1) Passage de paramètres par valeur

La valeur du paramètre ne change pas à la fin de l’exécution de la procédure.

Syntaxe :

Procédure nom_procédure (paramètre1 : type, …, paramètren : type) ;

//Déclarations des variables
Début
Suite d’instructions ;
FinProcédure ;

2) Passage de paramètres par variable

La valeur du paramètre précédé du mot-clé var change à la fin de l’exécution de la procédure.

Syntaxe :

Procédure nom_procédure (var paramètre1 : type, …, var paramètren : type) ;

//Déclarations des variables
Début
Suite d’instructions ;
FinProcédure ;

4.3. Les fonctions

Une fonction est un sous-programme qui renvoie une valeur d’un seul type. Ce type sera celui
de la fonction.

a) Syntaxe de la déclaration des fonctions :

Fonction nom_fonction (<liste des paramètres>) : type ;

//Déclarations des variables
Début
Suite d’instructions ;
Retourner (<nom_fonction>) ;
FinFonction ;

Exemple

Fonction Max (x, y : entier) : entier ;

Début
Si x >=y Alors
Maxx ;
Sinon
Maxy ;
Finsi
Retourner (Max) ;
FinFonction
23

Algorithmique –ENSP - Humanité numérique & Art numérique Ingénieur – Mme NINKO Lidwine
Remarque
Le corps de la fonction doit contenir au moins une instruction de retour de la valeur de la
fonction comme suit :
nom_fonction  expression

expression doit être de même type que la fonction

b) Appel de fonction
Un appel d’une fonction se fait dans une expression

Exemple
Algorithme Maximum_de_4réels ;
Var x1, x2, x3, x4 : réel ;
y1, y2, y3 : réel ;
Fonction Max (x, y : réel) : réel ;
Début
Si x>=y Alors
Maxx ;
Sinon
Max y ;
FinSi ;
Retourner (Max) ;
FinFonction ;
Début
Lire (x1, x2, x3, x4) ;
y1Max(x1, x2) ;
y2Max(x3, x4) ;
y3Max(y1,y2) ;
Ecrire (" le maximum est : ", y3) ;
Fin

c) Fonction récursive

Une fonction est dite récursive si elle s'appelle elle-même.

Récursivité

Principe qui consiste à décrire les étapes nécessaires à la résolution de problèmes en utilisant la
résolution du même problème sur des entrées plus petites.

Exemple d’une fonction calculant une factorielle de manière récursive :

Fonction fac (n : entier) : entier ;
Début
Si (n>1) Alors
facfac(n-1)*n ;
Sinon
fac1 ;
FinSi ;

24

Algorithmique –ENSP - Humanité numérique & Art numérique Ingénieur – Mme NINKO Lidwine
retourner(fac) ;
FinFonction ;

4.4. Variables globales, variables locales

o Variables globales : elles sont déclarées à l’extérieur des sous-programmes

o Variables locales : elles sont déclarées à l’intérieur du sous-programme

Exemple

Algorithme Principal ;
Var x, y : entier ; //variables globales
Procédure Proc (z : entier) ;
Var T : réel ; //variable locale
Début
….
FinProcédure ;
Début
….
Fin

Une même variable peut apparaître localement dans deux sous programmes différents.

4.5. Paramètres effectifs, paramètres formels

a) Paramètres formels

Une déclaration de procédure ou de fonction peut comporter après le nom de la procédure ou

de la fonction une liste de paramètres formels dont la syntaxe est la suivante.

Procédure nom_procédure(<liste de paramètres formels>) ;

Procédure nom_fonction(<liste de paramètres formels>) : type ;

Exemple 1 :

Procédure somme (a, b : entier, var c : entier) ;

Début
ca+b ;
FinProcédure ;

Exemple 2 :

Fonction somme (a, b : entier) : entier ;

Début
sommea+b ;
retourner (somme) ;
FinProcédure ;

b) Paramètres effectifs
25

Algorithmique –ENSP - Humanité numérique & Art numérique Ingénieur – Mme NINKO Lidwine
Au cas où la déclaration d’une procédure ou fonction comprend des paramètres formels, chaque
appel de cette procédure ou de fonction doit comporter des paramètres effectifs compatibles
dont la syntaxe est la suivante.

nom_procédure(<liste de paramètres effectifs>) ;

nom_fonction(<liste de paramètres effectifs>) : type ;

Il faut que les deux listes de paramètres formels et effectifs aient le même nombre de
paramètres et que les paramètres formels et effectifs correspondants soient compatibles.

Exemple

Algorithme Principal ;
Var t : réel ;
x, y : réel ;
Procédure Permute (var u,v : entier) ;
Var z : entier ;
Début
z u ;
uv ;
vz ;
FinProcédure ;
Début
…
Permute(x,y,t) /* interdit parce que le nombre de
paramètres formels est différent du nombre
de paramètres effectifs */
…
Permute(x,y) /* interdit parce que les paramètres formels
et effectifs ne sont pas compatibles */
Fin

26

Algorithmique –ENSP - Humanité numérique & Art numérique Ingénieur – Mme NINKO Lidwine