Module: ALGORITHMIQUE 1

Chapitre 8
Les fonctions et les procédures
Niveaux: 1A
Equipe ALGO

Année universitaire: 2022/2023

1
 Exemples Introductifs
EXEMPLE 1:
Problème: Éditer le relevé de notes d’un étudiant?
Il s’agit d’un problème complexe.
Pourquoi?
En effet, pour arriver à afficher la moyenne générale d’un étudiant ainsi que son rang, on doit passer par
les étapes suivantes :
1. Rechercher l’étudiant concerné par le relevé.
2. Chercher sa classe.
3. Pour la classe en question, on doit connaître les matières et les coefficients.
4. Pour chaque matière, on doit savoir la note obtenue par cet étudiant.
5. Une fois les notes connues, on doit calculer la moyenne.
6. Pour obtenir le rang, on doit obligatoirement passer par une étape de Tri.
2
7.C’est à ce moment là que nous puissions éditer le relevé de notes de cet étudiant.
 Notion des sous-programmes:
Décomposer pour résoudre
■ Analyse descendante: Approche incrémentale consistant à
analyser la spécification d’un problème selon son arborescence

■ Décomposition / combinaison: à chaque niveau de

l’arborescence :

◆ Décomposer le problème en un certain nombre de sous-problèmes

qu’on supposera résolus.

◆ Combiner les solutions des sous-problèmes pour résoudre le

problème courant.

◆Résoudre les sous-problèmes par la même approche.

3
 Avantages de la Programmation
Procédurale
■ La décomposition d’un problème en sous-problèmes faciles à résoudre, permet d’obtenir des algorithmes
qui sont :

● Lisibles et faciles à comprendre.

● Facile à maintenir : détection rapide de l’erreur et correction sans difficultés.

● Facile à faire évoluer : ajout facile d’autres fonctionnalités.

● Réutilisable : dans la résolution d’un problème, on peut constater qu'une suite d'actions

revient plusieurs fois.

4
 Principes de la Programmation
Procédurale
■ Un sous-programme est obligatoirement caractérisé par un nom (un identifiant) unique.
■ En algorithmique il existe deux types de sous-programmes :
■ Les fonctions
■ Les procédures
■ Le programme qui utilise un sous-programme (fonction ou procédure) est appelé le programme appelant.
■ Le sous-programme (fonction ou procédure) qui est appelé par un programme est dit programme appelé.

5
 Les fonctions
Définition:
■ Une fonction est sous-programme contenant un certain nombre d’instructions, qui retourne un résultat
unique affecté à son nom.
■ Une fonction est un sous programme qui retourne obligatoirement une valeur. Cette dernière sera placée
dans une variable qui porte le même nom que la fonction.
Remarques:
● Une fonction retourne un résultat unique implique qu’une fonction possède obligatoirement un type.
● Dans une fonction, on trouve des actions qui produisent le résultat ; ce dernier doit être affecté en fin de
traitement au nom de la fonction.

6
 Les fonctions
Représentation algorithmique:
Fonction nomfonct(param1:type1,param2:type2,…,paramN :TypeN) : typefonction
<partie déclarative>
Début (*fonction*)
<partie instructions>
nomfonct 🡨 Résultat
(* le résultat généré par les instructions doit être affecté au nom de la fonction *)
Fin (*fin fonction*)

Remarques:
● param1, param2, …, paramN sont appelés paramètres : Ce sont des variables qui permettent à la fonction
de communiquer avec l’extérieur.
● Ces paramètres déclarés lors de la définition de la fonction sont appelés paramètres formels.
● On peut trouver certaines fonctions sans paramètres : On déclare alors la fonction de la manière suivante :
Fonction nomfonct() : typefonction.
● Les paramètres de la fonction ne doivent jamais être lus à l’intérieur de la fonction sans que l’énoncé le
précise.
7
 Les fonctions
Exemple 1:
■ Écrire une fonction qui retourne la valeur absolue d’un entier N.

Solution

Fonction Val_abs(N : entier) : entier

Variable a : entier
Début
Si (N > 0) Alors a 🡨 N
Sinon a 🡨 -N
FinSi
Val_abs 🡨 a (* affecter le résultat au nom de la fonction : Val_abs *)
Fin
8
 Les fonctions
Exemple 2:
■ Écrire une fonction qui retourne la moyenne de deux réels x et y.

Solution

Fonction Moyenne(x : réel, y : réel) : réel

Début
Moyenne 🡨 (x+y)/2
Fin

9
 Les fonctions
Appel d’une fonction:
■ L’appel d’une fonction est une expression, dont la valeur est le résultat retourné par cette fonction ; son appel doit
alors se faire soit dans une action d’affectation soit dans une action d’écriture.
● Nomvar 🡨 nomfonct(var1, var2,…, varN)
● Écrire (nomfonct(var1,var2,…..,varN))
Remarques:
● Nomvar et nomfonct doivent avoir le même type.
● On doit avoir autant de paramètres formels (param1, param2, …, paramN) que de paramètres utilisés par le
programme appelant (var1, var2,…., varN).
● Les paramètres utilisés dans le programme appelant sont appelés paramètres effectifs.
● L’ordre des paramètres formels doit être respecté lors de l’appel : les varI doivent correspondre aux paramI.
● Lors de l’appel, chacun des paramètres formels est remplacé par le paramètre effectif .
● La liste des paramètres effectifs doit être compatible avec la liste des paramètres formels de la déclaration de la
fonction.
● Une fonction peut ne pas avoir de paramètres (Fonction message() : chaine) 10
 Les fonctions
Appel de la fonction:

▪ Exemple:
Algorithme Calcul (* programme appelant *)
Variable a,b : réel

Fonction Moyenne(x : réel, y : réel) : réel

Début
Moyenne 🡨 (x+y)/2
Fin

Début (* programme appelant *)

Lire (a)
Lire (b)
Écrire (Moyenne(a,b))
Fin

11
 Les fonctions
Appel de la fonction:

▪ Exemple: Fonction sans paramètres

Écrire une fonction qui retourne le message ‘Bonjour’

Fonction message() : chaine

Début
Message 🡨 "Bonjour"
Fin

12
 Les procédures
Définition:
■ Une procédure est un sous-programme qui peut produire zéro ou plusieurs résultats.

Représentation algorithmique:

Procédure nomproc(param1:type1,param2:type2,…,paramN :TypeN)

<Partie déclarative>
Début (*procédure*)
<Partie instructions>
Fin (*fin procédure*)

13
 Les procédures
Remarques:
● param1, param2, …, paramN sont appelés paramètres : Ce sont des variables qui permettent à la
procédure de communiquer avec l’extérieur.
● Ces paramètres déclarés lors de la définition de la procédure sont appelés paramètres formels.
● On peut trouver certaines procédures sans paramètres ; on déclare alors la fonction de la manière
suivante : Procédure nomproc().
● Les paramètres de la procédure ne doivent jamais être lus à l’intérieur de la procédure sans que
l’énoncé ne l’indique.
● Lors de l’appel, chacun des paramètres formels est remplacé par le paramètre effectif .
● La liste des paramètres effectifs doit être compatible avec la liste des paramètres formels de la
déclaration de la procédure.

14
 Les procédures

Exemple 1:
■ Écrire une procédure permettant d’afficher la somme de deux entiers.
Solution
Procédure aff_somme(a :entier, b :entier)
Variable S : entier
Début
S🡨a+b
Écrire (S)
Fin

15
 Les procédures
Exemple 2: Procédure sans paramètres

Procédure message()
Variable mess : chaine
Début
Lire(mess)
Écrire(mess)
Fin

16
 Les procédures
Appel de la procédure:
■ À la différence d’une fonction, une procédure est appelée par son nom et ses paramètres effectifs, dans le
programme appelant:

Nomproc(var1, var2, …., varN)

Remarques
(i) On doit avoir autant de paramètres formels (param1, param2, …, paramN) que de paramètres utilisés par le
programme appelant (var1, var2,…., varN).
(ii) Les paramètres utilisés dans le programme appelant sont appelés paramètres effectifs.
(iii)L’ordre des paramètres formels doit être respecté lors de l’appel : les varI doivent correspondre aux
paramI.

17
 Les procédures
Appel de la procédure:
Algorithme affiche
▪ Exemple:
Variable x,y : entier
Procédure aff_somme(a :entier, b :entier)
Variable S : entier
Début (*proc*)
S🡨a+b
Écrire(S)
Fin (*proc*)

Début (*algo*)
Écrire(‘donnez un entier x : ‘)
Lire(x)
Écrire(‘donnez un entier y : ‘)
Lire(y)
(* appel de la procédure aff_somme *)
aff_somme(x,y)
Finalgo
18
 La portée d’une variable
❖ La portée d'une variable est l’étendue où cette variable est visible dans un programme (les
instructions de ces sous-programmes peuvent utiliser cette variable).

❖ Une variable définie au niveau du programme principal (celui qui résout le problème initial, le
problème de plus haut niveau) est appelée variable globale.
⮚ Sa portée est totale : Tout sous-programme du programme principal peut utiliser cette
variable.

❖ Une variable définie au sein d'un sous programme est appelée variable locale.
⮚ La portée d'un variable locale est uniquement le sous-programme qui la déclare.

19
PARTIE II

20
 Le passage des paramètres
Problématique : On considère l’algorithme suivant :
Algorithme afficher
Variable x, y : entier
Procédure affich_ab (a :entier, b :entier)
Variable c : entier
Début
a🡨 a – 1
b🡨b–1
c🡨a+b
Écrire(c)
Fin
Début (*afficher*)
Lire(x)
Lire(y)
affich_ab(x,y)
Écrire(x)
Écrire(y)

Fin 21
 Le passage des paramètres
▪ En appelant la procédure affich_ab(x,y), on va se poser automatiquement la question suivante : les
valeurs de x et de y vont elles changer après l’exécution de cette procédure ?

▪ La réponse dépend du comportement des paramètres lors de l’appel. Ce comportement doit être indiqué
préalablement lors de la définition de la procédure et plus exactement lors de la déclaration des
paramètres.

▪ Dans ce cas, un paramètre n’est plus caractérisé par son nom et son type mais en plus son comportement.

▪ Ce comportement est dit en termes de sous-programmes, le mode de passage des paramètres.

22
 Le passage des paramètres

■ Le passage de paramètres s’applique aussi bien pour les fonctions que pour les procédures.
On distingue trois modes de passage :

● Un mode de passage de type donnée ou par valeur qu’on note DON.

● Un mode de passage de type résultat ou par référence qu’on note RES.

.
● Un mode de passage de type donné et résultat qu’on note DONRES.

23
 Le passage des paramètres
❖ Le mode de passage de type DON:
■ On dit qu’un paramètre est fourni en donnée s’il est fourni par le programme appelant, sa valeur reste
inchangée après l’exécution du programme appelé.

■ Un paramètre de type donné est noté DON et déclaré de la manière suivante :

Déclaration: Procédure nomprocéd(DON param1 : typeparam1, DON param2 : typeparam2,….)

Exemple: Procédure Test1(DON p1 : réel)

▪ Si un paramètre n’est précédé d’aucun mode de passage, il est par défaut de type DON.

24
 Le passage des paramètres
❖ Le mode de passage de type RES:
■ On dit qu’un paramètre est fourni en résultat, s’il est retourné par la procédure appelée ; l’exécution de
la procédure appelée calcule une valeur qui sera affectée à ce paramètre, en fin du traitement.
■ Un paramètre de type résultat est noté RES et déclaré de la manière suivante :

Déclaration: Procédure nomprocéd(RES param1 : typeparam1, RES param2 : typeparam2,….)

Exemple: Procédure Test2(RES p2 : réel)

25
 Le passage des paramètres
❖ Le mode de passage de type DON et RES:
Algorithme exemple
Variable x,y,min,max : Entier
fonction minimum (a : Entier, b : Entier) : Entier
...
fonction maximum (a : Entier, b : Entier) : Entier
...
Procédure calculerMinMax ( DON a,b: Entier , RES min2,max2 : Entier )
Début
min2 🡨 minimum(a,b)
max2 🡨 maximum(a,b)
Fin
début
écrire("Entrez deux entiers :")
lire(x)
lire(y)
calculerMinMax (x, y, min, max)
écrire("la valeur la plus petite est ",min," et la plus grande est ",max)
Fin
26
 Le passage des paramètres
❖ Le mode de passage de type DONRES:
■ On dit qu’un paramètre est fourni en donnée et résultat, s’il est fourni par le programme appelant et
modifié par la procédure appelée.
■ Un paramètre de type donnée et résultat est noté DONRES et déclaré de la manière suivante :

Déclaration: Procédure nomprocéd(DONRES param1 : typeparam1, DONRES param2 :

typeparam2,….)

Exemple: Procédure Test3(DONRES p3 : réel)

27
 Le passage des paramètres
❖ Le mode de passage de type DONRES:
Algorithme Exemple2
variable a, b : entier

procédure permuter (DONRES val1,val2 :entier)

variable aux :entier
début
aux←val1
val1←val2
val2←aux
Fin

début
Ecrire("donner deux entiers")
Lire(a,b)
permuter(a,b)
Ecrire(“Après permutation les deux entiers“,a,b)
fin
28
 Application
Il s’agit de lire l’algorithme suivant et de dire pour chaque appel de procédure, s’il est possible ou non ; dans les deux cas de
réponse il faudra justifier.
Début (* Algorithme Appelant *)
Algorithme Appelant a 🡨 45.0
Variable a, b, c : réel Test1(33.0)
Procédure Test1 (DON p1 : Réel) Test1(a)
/*Contenu de la procédure Test1 supposé connu*/ Test1(35.0*a-2.0)
Procédure Test2 (RES p2 : Réel) Test1(b)
/*Contenu de la procédure Test2 supposé connu*/ Test2(a)
Procédure Test3 (DONRES p3 : Réel) Test2(b)
/*Contenu de la procédure Test3 supposé connu*/ Test2(a*4.0)
Test2(35.0)
Test3(a)
Test3( c )
Test3(45.0)
Test3(a*2.0)
Fin (* Algorithme *)

29
 Solution
✔
Appel Justification

✔✔
Test1(33.0) 33 étant une constante donc fourni par le programme appelant cet appel est donc Correct.

Test1(a) a étant fourni par le programme appelant (a=45); cet appel est donc Correct.
Test1(35.0*a-2.0) L’expression (35*a-2) est fourni par le programme appelant; cet appel est donc Correct.

🗶
✔✔
Test1(b) b n’étant pas fourni par le programme appelant; cet appel est donc Incorrect.
Test2(a) a peut être modifié par le programme appelé; cet appel est donc Correct.
Test2(b) b peut être modifié par le programme appelé; cet appel est donc Correct.
Test2(a*4.0) (a*4.0) ne peut pas être modifié par le programme appelé : ce n’est pas un nom de variable ; cet
appel est donc Incorrect. 🗶

✔
Test2(35.0) 35 étant une constante, elle ne peut pas être modifiée ; cet appel est donc Incorrect. 🗶
Test3(a) a est fourni par le programme appelant et peut être modifié par le programme appelé; cet appel est
donc Correct.
Test3( c ) C n’est pas fourni par le programme appelant et peut être modifié par le programme appelé; cet
appel est donc Incorrect. 🗶
Test3(45.0) 45 est fourni par le programme appelant et ne peut pas être modifié par le programme appelé
(c’est une constante); cet appel est donc Incorrect. 🗶
Test3(a*2.0) (a*2) est fourni par le programme appelant et ne peut pas être modifié par le programme
appelé(c’est une expression); cet appel est donc Incorrect. 🗶
30