Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

Chapitre 6 : Fonctions et Procédures

1 – Introduction
Nous savons que la construction d’un algorithme, pour résoudre un problème donnée, repose
sur l’écriture d’un certain nombre d’instructions dans un ordre séquentiel et logique.

Il apparait fréquemment qu’un même ensemble d’instructions se réalise à divers

emplacements de l’algorithme. Pour éviter la peine de recopier une même série d’instructions
et aussi pour diminuer la taille de l’algorithme, on fera de cet ensemble un sous-algorithme,
définis séparément de l’algorithme principal.

2 – Notion de sous-algorithme
La notion de sous-algorithme représente toute la puissance du langage algorithmique. En fait,
c’est la possibilité de structurer encore davantage l’algorithme en créant de nouveaux ordres,
définis indépendamment de l’algorithme principal, utilisables dans le corps de l’algorithme.
Cela permet d’avoir un algorithme beaucoup plus petit et bien visible. On distingue deux types
de sous-algorithmes : les fonctions et les procédures.

3 – Notion de fonction
Une fonction est un sous-algorithme (sous-programme en langage de programmation) qui
fournit un résultat à partir des données qu’on lui apporte.

Pour créer une fonction, il faut déclarer l’existence de cette fonction, lui donner un nom
(identificateur), définir son type (c’est-à-dire le type du résultat qu’elle renvoie), décrire le
traitement qu’elle permet de réaliser et, enfin, retourner le résultat qu’elle produit.

3.1. Définition d’une fonction

Une fonction peut être définie n'importe où, à l'extérieur d'un algorithme. La définition de la
fonction se compose :
 de son en-tête qui comprend :
o son identificateur
o la liste de ses paramètres formels et de leur type

1
Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

o le type de la valeur qu'elle renvoie

 des déclarations locales (constantes ou variables)
 et de son corps qui comprend :
o les instructions qui calculent son résultat
o au moins une instruction retourner qui renvoie la valeur du résultat

Syntaxe :

fonction <ident-fonction>(<ident-paramètre> : <type>,...,

<ident-paramètre> : <type>) : <type-fonction>
Variables locales
<ident-variable> : <type>
....
<ident-variable> : <type>
Début
<instructions>
retourner <expression>
Fin

Exemple :

Ecrire un algorithme qui va lire 4 variables a, b, c et d et afficher la plus grande valeur.

Solution sans utilisation de fonction :

Ici, la même instruction conditionnelle est répétée trois fois :

Algorithme Maxquatre1
Variables
a, b, c, d : entier
mab, mcd, maxi : entier
Début
Ecrire("Entrez les 4 nombres :")
lire(a, b, c, d)

si a > b alors
mab ← a
sinon
mab ← b
finsi

si c > d alors
mab ← c
sinon
mab ← d

2
Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

finsi

si mab > mcd alors

maxi ← mab
sinon
maxi ← mcd
finsi

écrire(maxi)
Fin

Solution avec utilisation de fonction :

Les trois instructions conditionnelles analogues sont remplacées par des appels à une même
fonction qui s'applique à des valeurs différentes. Ceci rend plus compréhensible ce que fait
l'algorithme en évitant de dupliquer des instructions identiques.
Au lieu de répéter le code qui recherche la plus grande entre 2 valeurs, il serait mieux d’écrire
une fonction (appelée maxdeux par exemple) qui prend 2 entiers en paramètres et qui renvoie
le plus grand. Ainsi cette fonction sera appelée à chaque fois qu’on cherche le plus grand entre
2 entiers.

Algorithme Maxquatre2
Variables
a, b, c, d : entier
mab, mcd, maxi : entier
Début
Ecrire("Entrez les 4 nombres :")
lire(a, b, c, d)
mab ← maxdeux(a, b)
mcd ← maxdeux(c, d)

maxi ← maxdeux(mab, mcd)

écrire(maxi)
Fin

/*Définition de la fonction maxdeux*/

fonction maxdeux(x : entier, y : entier) : entier
Variables locales
mxy : entier
Début
si x > y alors
mxy ← x
sinon

3
Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

mxy y ←
finsi
retourner(mxy)
Fin

3.2. Appel de la fonction

La fonction est appelée depuis un algorithme principal, ou depuis une autre fonction (ou
procédure), dans l'instruction où le résultat qu'elle renvoie doit être utilisé.

Syntaxe :
<ident-variable> ←
<ident-fonction>(<ident/valeur-paramètre>, ...,
<ident/valeur-paramètre>)

Exemple :
mab ← maxdeux(a, b)
ecrire('la plus grande valeur est :', maxdeux(mab, mcd))
pg ← maxdeux(15, 11)

3.3. Passage de paramètres

Dans la définition de la fonction : paramètres formels
Dans l'appel de la fonction : paramètres effectifs
Il doit y avoir une correspondance entre les paramètres formels et les paramètres effectifs, la
correspondance étant régie par l'ordre d'écriture.
À l'appel de la fonction, le premier paramètre effectif passe sa valeur au premier paramètre
formel, le deuxième paramètre effectif passe sa valeur au deuxième paramètre formel, et ainsi
de suite. La fonction exécute son code puis renvoie son résultat.
Les paramètres qui se correspondent doivent avoir des types compatibles.

4
Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

4 – Notion de procédure
Comme les fonctions, les procédures sont des blocs d'instructions référencés par un nom et
qui répondent à un traitement précis. Cependant elles ont des rôles différents :

 Une fonction renvoie une valeur qu'elle a calculée à partir des valeurs reçues en
paramètres. L'appel d'une fonction se fait dans le même contexte qu'une expression au
sein d'une instruction.
 Une procédure exécute des instructions qui utilisent des valeurs reçues en paramètres,
mais qui peuvent aussi modifier l'environnement mémoire de l'unité qui l'appelle.
L'appel d'une procédure se fait dans le même contexte qu'une instruction.
 Fonction et procédures sont désignées par le nom générique de sous-programmes.

4.1. Définition d’une procédure

Une procédure peut être définie n'importe où, à l'extérieur d'un algorithme. La définition de
la procédure se compose de :
 son en-tête qui comprend :
o son identificateur
o la liste de ses paramètres formels et de leur type et de leur statut
 des déclarations locales (constantes ou variables)
 les instructions qui réalisent son traitement

Syntaxe :

procédure <ident-procédure>(<ident-paramètre> : <type>, ..., <ident-

paramètre> : <type>)
Variables locales
<ident-variable> : <type>
....
<ident-variable> : <type>
Début
<instructions>
Fin

Exemple :
Supposons que l'on veuille afficher une suite de lignes comme le montre le schéma suivant :

Au lieu de programmer chaque ligne l'une après l’autre, on peut remarquer que chaque ligne
est définie de manière non ambiguë dès que l'on connaît le caractère qui la compose et le
nombre de caractères qu'elle comporte. En tenant compte de cette remarque, on peut définir

5
Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

une procédure dont le travail est d'afficher une ligne connaissant le caractère à afficher, ainsi
que le nombre de caractères.
procédure ligne (nb : entier, car : caractère)
Algorithme dessin Variables locales
Début i : entier
ligne(1, ‘*’) Début
ligne(4, ‘+’) Pour i de 1 à nb faire
ligne(3, ‘#’) écrire(car)
ligne(7, ‘o’) Finpour
Fin écrire(CRLF) /* passage à la ligne */
Fin

4.2. Appel de la procédure

La procédure est appelée depuis un algorithme principal, ou depuis une autre procédure, là
où les instructions qu'elle renferme doivent être exécutées. Elle est appelée par son
identificateur suivi de la liste des paramètres effectifs placés entre parenthèses.

Syntaxe :
<ident-procédure>(<ident/valeur-paramètre>, ..., <ident/valeur-
paramètre>)

Exemple :
ligne(1, ‘*’)

4.3. Paramètres
Il doit y avoir une correspondance biunivoque entre les paramètres effectifs et les paramètres
formels. La correspondance est assurée par l'ordre d'écriture dans les deux listes. Il y a 3 types
des paramètres : paramètres d’entrée, paramètres de sortie et paramètres d’entrée-sortie.

4.3.1. Paramètres d’entrée

Le paramètre effectif peut prendre la forme de n'importe quelle expression (constante,
variable ou expression) dont la valeur est copiée dans le paramètre formel pour être consultée
ou utilisée dans la procédure.

4.3.2. Paramètres de sortie

Le paramètre effectif est nécessairement un identificateur de variable qui reçoit une valeur
produite par la procédure par l'intermédiaire du paramètre formel.
6
 Cours : Algorithme et Programmation Enseignant : Moutari Mahamane

4.3.3. Paramètres d’entrée-sortie

Le paramètre effectif est un identificateur de variable qui contient une valeur. Celle-ci est
envoyée à la procédure via le paramètre formel. La procédure modifie la valeur et la renvoie
au paramètre effectif.

Exemple :
Pour classer par ordre croissant trois lettres rangées dans trois variables c1, c2, et c3, on
procède comme suit :
Variables : c1 c2 c3
Valeurs initiales : T Z A
on compare le contenu de c1 et de c2 : dans l'ordre T Z A
on compare et on échange le contenu de c2 et de c3 T A Z
on compare et on échange le contenu de c1 et de c2 A T Z

Les procédures classer et échanger sont susceptibles de modifier les valeurs des variables
passées en paramètres (paramètres d'entrée/sortie).

procédure classer(Entrée/Sortie
a, b : caractère)
Début
Algorithme tri_lettres si a > b alors
échanger(a, b)
Début finsi
Ecrire('Entrez les 3 lettres :') Fin

lire(c1, c2, c3) procédure échanger(Entrée/Sortie

x, y : caractère)
classer(c1, c2) Variables locales
classer(c2, c3) aide : caractère
Début
classer(c1, c2)
écrire('Après le tri :',c1, c2, c3)
aide ← x

Fin x ← y

y ← aide
Fin