Algorithmique

Fonctions et procédures

Pr. Khalid FAKHAR

1ère Année Préparatoire Intégrée

École Nationale des Sciences Appliquées - Berrechid
Université Hassan 1er
Année 2021/2022
Fonctions et procédures

I Certains problèmes conduisent à des programmes longs,

difficiles à écrire et à comprendre. On les découpe en des
parties appelées sous-programmes ou modules
I Les fonctions et les procédures sont des modules
(groupe d’instructions) indépendants désignés par un
nom. Elles ont plusieurs intérêts :
I permettent de "factoriser" les programmes, càd de
mettre en commun les parties qui se répètent
I permettent une structuration et une meilleure lisibilité
des programmes
I facilitent la maintenance du code (il suffit de modifier
une seule fois)
I ces procédures et fonctions peuvent éventuellement être 1/18
réutilisées dans d’autres programmes
Fonctions

I Le rôle d’une fonction en programmation est similaire à

celui d’une fonction en mathématique : elle retourne un
résultat à partir des valeurs des paramètres
I Une fonction s’écrit en dehors du programme principal
sous la forme :
Fonction nom_fonction (paramètres et leurs types ) : type_fonction
Instructions constituant le corps de la fonction
retourne ...
FinFonction
I Pour le choix du nom_fonction il faut respecter les
mêmes règles que celles pour les noms de variables
I type_fonction est le type du résultat retourné
2/18
I retourne sert à retourner la valeur du résultat
Utilisation des fonctions

I L’utilisation d’une fonction se fera par simple écriture de

son nom dans le programme principal. Le résultat étant
une valeur, devra être affecté ou être utilisé dans une
expression, une écriture, ...
I Exemple :
Variables z : réel, b : booléen
Début
b ← estPair(3)
z ← 5*sommeCarre(7,2)+1
Ecrire("sommeCarre(3,5)=", sommeCarre(3,5))
Fin
I Lors de l’appel estPair(3) le paramètre formel n est
3/18
remplacé par le paramètre effectif 3
Procédures (1)

I Dans certains cas, on peut avoir besoin de répéter une

tache dans plusieurs endroits du programme, mais
que dans cette tache on ne calcule pas de résultats ou
qu’on calcule plusieurs résultats à la fois.
I Dans ces cas on ne peut pas utiliser une fonction, on
utilise une procédure.
I Une procédure est un sous-programme semblable à une
fonction mais qui ne retourne rien.

4/18
Procédures (2)

I Une procédure s’écrit en dehors du programme

principal sous la forme :

Procédure nom_procedure (paramètres et leurs types)

Instructions constituant le corps de la procédure
FinProcédure

I Remarque : une procédure peut ne pas avoir de

paramètres.

5/18
Appel d’une procédure
I L’appel d’une procédure, se fait dans le programme
principal ou dans une autre procédure par une
instruction indiquant le nom de la procédure :
Procédure exemple_proc(...)
...
FinProcédure
Programme principal
Début
exemple_proc(...)
...
Fin
I Remarque : contrairement à l’appel d’une fonction, on
ne peut pas affecter la procédure appelée ou l’utiliser dans
une expression. L’appel d’une procédure est une 6/18
instruction autonome.
Paramètres d’une procédure

I Les paramètres servent à échanger des données entre

le programme principal (ou la procédure appelante) et la
procédure appelée.
I Les paramètres placés dans la déclaration d’une procédure
sont appelés paramètres formels. Ces paramètres
peuvent prendre toutes les valeurs possibles mais ils sont
abstraits (n’existent pas réellement).
I Les paramètres placés dans l’appel d’une procédure sont
appelés paramètres effectifs. ils contiennent les valeurs
pour effectuer le traitement.
I Le nombre de paramètres effectifs doit être égal au
nombre de paramètres formels. L’ordre et le type des
paramètres doivent correspondre. 7/18
Transmission des paramètres
I Il existe deux modes de transmission de paramètres dans
les langages de programmation :
I La transmission par valeur : les valeurs des paramètres
effectifs sont affectées aux paramètres formels correspondants
au moment de l’appel de la procédure. Dans ce mode, le
paramètre effectif ne subit aucune modification.
I La transmission par adresse (ou par référence) : les
adresses des paramètres effectifs sont transmises à la
procédure appelante. Dans ce mode, le paramètre effectif
subit les mêmes modifications que le paramètre formel lors de
l’exécution de la procédure.
Remarque : le paramètre effectif doit être une variable (et
non une valeur) lorsqu’il s’agit d’une transmission par adresse.
I En pseudo-code, on va préciser explicitement le mode de 8/18
transmission dans la déclaration de la procédure.
Transmission des paramètres : exemples (1)
Procédure incrmt(x : entier par valeur, y : entier par adresse)
x←x+1
y←y+1
FinProcédure
Programme principal
Variables n, m : entier
Début
n←3
m←3
incrmt(n,m)
Ecrire("n = ", n, " et m = ", m)
Fin
Remarque : l’instruction x ← x+1 ; n’a pas de sens avec
9/18
un passage par valeur. (Résultat : n=3, m=4).
Transmission des paramètres : exemples (2)

Procédure qui calcule la somme et le produit de deux entiers :

Procédure sommeProduit(x, y : entier par adresse, som, prod :
entier par adresse)
som ← x + y
prod ← x * y
FinProcédure

Procédure qui échange le contenu de deux variables :

Procédure echange(x : réel par adresse, y : réel par adresse)
Varibales z : réel
z←x
x←y
y←z
10/18
FinProcédure
Variables locales et globales (1)

I On peut manipuler 2 types de variables dans un module

(procédure ou fonction) : des variables locales et des
variables globales. Elles se distinguent par ce qu’on
appelle leur portée (leur "champ de définition", leur
"durée de vie").
I Une variable locale n’est connue qu’à l’intérieur du
module ou elle a été définie. Elle est créée à l’appel du
module et détruite à la fin de son exécution.
I Une variable globale est connue par l’ensemble des
modules et le programme principal. Elle est définie durant
toute l’application et peut être utilisée et modifiée par les
différents modules du programme.
11/18
Variables locales et globales (2)

I La manière de distinguer la déclaration des variables

locales et globales diffère selon le langage.
En général, les variables déclarées à l’intérieur d’une
fonction ou procédure sont considérées comme variables
locales.
I En pseudo-code, on va adopter cette règle pour les
variables locales et on déclarera les variables globales dans
le programme principal.
I Conseil : Il faut utiliser autant que possible des variables
locales plutôt que des variables globales. Ceci permet
d’économiser la mémoire et d’assurer l’indépendance de la
procédure ou de la fonction. 12/18
Récursivité

I Un module (fonction ou procédure) peut s’appeler

lui-même : on dit que c’est un module récursif.
I Tout module récursif doit posséder un cas limite (cas
trivial) qui arrête la récursivité.

I Exemple :
Fonction fact(n : entier) : entier
Si n == 0 alors
retourne 1
Sinon
retourne n*fact(n-1)
FinSi
FinFonction 13/18
Fonctions récursives : exercice

Écrivez une fonction récursive (puis itérative) qui calcule le

terme n de la suite de Fibonacci définie par :
U(0) = U(1) = 1
U(n) = U(n − 1) + U(n − 2)

14/18
Fonctions récursives : solution récursive

Fonction fibonacci(n : entier) : entier

Si n == 1 OU N == 0 alors
retourne 1
Sinon
retourne fibonacci(n-1)+fibonacci(n-2)
FinSi
FinFonction

15/18
Fonctions récursives : solution itérative

Fonction fibonacci(n : entier) : entier

Variables i, avantDernier, dernier, nouveau : entier
Si n = 1 OU n = 0 alors
retourne 1
FinSi
avantDernier ← 1
dernier ← 1
Pour i allant de 2 à n faire
nouveau ← dernier + avantDernier
avantDernier ← dernier
dernier ← nouveau
FinPour
retourne nouveau
16/18
FinFonction
Procédures récursives : exercice

Écrivez une procédure récursive qui permet d’afficher la valeur

binaire d’un entier n.

17/18
Procédures récursives : solution

Procédure binaire(n : entier)

Si n 6= 0 alors
binaire(n/2)
Ecrire(n % 2)
FinSi
FinProcédure

18/18