ALGORITHMIQUE

Fonctions et procédures

1
Fonctions et procédures
⚫ Certains problèmes conduisent à des programmes longs, difficiles à
écrire et à comprendre. On les découpe en des parties appelées
sous-programmes ou modules

⚫ 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 :
• permettent de "factoriser" les programmes, càd de mettre en commun
les parties qui se répètent

• permettent une structuration et une meilleure lisibilité des programmes

• facilitent la maintenance du code (il suffit de modifier une seule fois)

• ces procédures et fonctions peuvent éventuellement être réutilisées dans

d'autres programmes

2
Fonctions
⚫ 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

⚫ 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
⚫ Pour le choix d'un nom de fonction il faut respecter les mêmes règles que celles
pour les noms de variables
⚫ type_fonction est le type du résultat retourné
⚫ L'instruction retourne sert à retourner la valeur du résultat
3
Fonctions : exemples
⚫ La fonction SommeCarre suivante calcule la somme des carrées de
deux réels x et y :
Fonction SommeCarre (x : réel, y: réel ) : réel
variable z : réel
z ←x^2+y^2
retourne (z)
FinFonction

⚫ La fonction Pair suivante détermine si un nombre est pair :

Fonction Pair (n : entier ) : booléen

retourne (n%2=0)
FinFonction
4
Utilisation des fonctions
⚫ L'utilisation d'une fonction se fera par simple écriture de son nom
dans le programme principale. Le résultat étant une valeur, devra
être affecté ou être utilisé dans une expression, une écriture, ...

⚫ Exepmle : Algorithme exepmleAppelFonction

variables z : réel, b : booléen
Début
b ←Pair(3)
z ←5*SommeCarre(7,2)+1
écrire("SommeCarre(3,5)= ", SommeCarre(3,5))
Fin

⚫ Lors de l'appel Pair(3) le paramètre formel n est remplacé par le

paramètre effectif 3
5
Procèdures
⚫ 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

⚫ Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure

⚫ Une procédure est un sous-programme semblable à une fonction mais qui

ne retourne rien
⚫ Une procédure s'écrit en dehors du programme principal sous la forme :

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

Instructions constituant le corps de la procédure

FinProcédure
⚫ Remarque : une procédure peut ne pas avoir de paramètres
6
Appel d'une procédure
⚫ L'appel d'une procédure, se fait dans le programme principale ou dans une
autre procédure par une instruction indiquant le nom de la procédure :
Procédure exemple_proc (…)
…
FinProcédure

Algorithme exepmleAppelProcédure
Début
exemple_proc (…)
…
Fin

⚫ 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 instruction autonome

7
Paramètres d'une procédure
⚫ Les paramètres servent à échanger des données entre le programme
principale (ou la procédure appelante) et la procédure appelée

⚫ 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)

⚫ 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

⚫ 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

8
Transmission des paramètres
Il existe deux modes de transmission de paramètres dans les langages de
programmation :

⚫ 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

⚫ 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

⚫ En pseudo-code, on va préciser explicitement le mode de transmission dans

la déclaration de la procédure
9
 Transmission des paramètres : exemples
Procédure incrementer1 (x : entier par valeur, y : entier par adresse)
x ← x+1
y ← y+1
FinProcédure

Algorithme Test_incrementer1
variables n, m : entier
Début
n←3
m←3
incrementer1(n, m) résultat :
écrire (" n= ", n, " et m= ", m) n=3 et m=4
Fin

Remarque : l'instruction x ← x+1 n'a pas de sens avec un passage par valeur
10
Transmission par valeur, par adresse : exemples
Procédure qui calcule la somme et le produit de deux entiers :
Procédure SommeProduit (x,y: entier par valeur, som, prod : entier par adresse)
som ← x+y
prod ← x*y
FinProcédure

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

Procédure Echange (x : réel par adresse, y : réel par adresse)
variables z : réel
z←x
x←y
y←z
FinProcédure

11
Variables locales et globales (1)
⚫ 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")

⚫ 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

⚫ Une variable globale est connue par l'ensemble des modules et le

programme principale. Elle est définie durant toute l’application et peut être
utilisée et modifiée par les différents modules du programme

12
Variables locales et globales (2)
⚫ 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

• En pseudo-code, on va adopter cette règle pour les variables locales et on

déclarera les variables globales dans le programme principale

• 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

13
Fonctions et procédures en Maple (1)
⚫ En Maple, il n'y a pas de distinction entre les notions de fonction et
procédure. Les deux se déclarent de la même façon comme suit :

identificateur:= proc (paramètres)

local l1 , ..., l n ;
global g1 , ..., g k ;
instructions
résultat
end;

⚫ Identificateur est le nom de la fonction ou de la procédure

⚫ En Maple, on précise explicitement si les variables sont locales ou

globales par les mots clés local et global
14
Fonctions et procédures en Maple (2)
⚫ Une variable globale est connue en dehors de la procédure où elle a été
définie dans l'ensemble de la session de calcul

⚫ Les paramètres, les variables locales et globales sont facultatifs, ils peuvent
ne pas figurer dans la déclaration

⚫ Une procédure Maple peut rendre un seul résultat (comme une fonction),
plusieurs résultats ou aucun résultat

⚫ Pour rendre plusieurs résultats, on peut utiliser une liste, un ensemble, un

tableau (on verra ces structures la séance prochaine)

⚫ Le résultat de la procédure est donné soit implicitement par la dernière

instruction, soit par la commande RETURN

⚫ RETURN ( v1 , ... , v n ) arrête le déroulement de la procédure et renvoie les

valeurs de v1 , ... , v n sous forme d'une séquence

15
Procédures Maple : remarques
⚫ Maple interdit la modification de la valeur d'un paramètre à
l'intérieur d'une procédure (pas de transmission par adresse)

⚫ Après end; Maple affiche le texte de la procédure. Dans le cas où

end est suivi de : rien n'est affiché
> carre:=proc(x,y)
> x^2+y^2;
> end; carre:=proc (x, y) x^2+y^2 end proc

⚫ En Maple, une procédure peut être appelée sans être affectée. Elle
peut aussi être affectée à une variable
> carre(1,2); 5
> a:=carre(3,3); a := 18

16
Procédures Maple : exemples (1)

> exemple:=proc(a,b)
> local c,d,e;
> c:=a+b; d:=a-b; e:=a*b;
> RETURN(c,d,e);
> d:=c+e;
> end:

> exemple(4,7); 11, -3, 28

Remarque : l'exécution s'arrête après RETURN. L'instruction d:=c+e n'est

pas exécutée, le résultat est donné sous forme d'une séquence

17
Procédures Maple : exemples (2)
Exemple : procédure qui calcule la somme des n premiers entiers
> somme:=proc()
> local n,i,som;
> som:=0;
> n:=readstat(`entrez la valeur de n : `);
> for i from 1 to n do
> som:=som+i;
> od;
> print(`somme=`,som);
> end;

> somme(); sur l'écran apparaît le message :

entrez la valeur de n :
si on entre 3, on obtient somme=,6

18
Récursivité
⚫ Un module (fonction ou procédure) peut s'appeler lui-même: on dit
que c'est un module récursif

⚫ Tout module récursif doit posséder un cas limite (cas trivial) qui
arrête la récursivité

⚫ Exemple : Calcul du factorielle

Fonction fact (n : entier ) : entier
Si (n=0) alors
retourne (1)
Sinon
retourne (n*fact(n-1))
Finsi
FinFonction
19
Fonctions récursives : exercice
⚫ Ecrivez 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)

Fonction Fib (n : entier ) : entier

Variable res : entier
Si (n=1 OU n=0) alors
res ←1
Sinon
res ← Fib(n-1)+Fib(n-2)
Finsi
retourne (res)
FinFonction

20
Fonctions récursives : exercice (suite)
⚫ Une fonction itérative pour le calcul de la suite de Fibonacci :
Fonction Fib (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
Nouveau← Dernier+ AvantDernier
AvantDernier ←Dernier
Dernier ←Nouveau
FinPour
retourne (Nouveau)
FinFonction
Remarque: la solution récursive est plus facile à écrire
21
Procédures récursives : exemple
⚫ Une procédure récursive qui permet d'afficher la valeur binaire d'un entier n

Procédure binaire (n : entier )

Si (n<>0) alors
binaire (n/2)
écrire (n mod 2)
Finsi
FinProcédure

22