Université Cheikh Anta Diop de DAKAR

Faculté des Sciences et technique

Département Mathématique et Informatique

Chapitre 6 - Procédure et Fonction

Cours d’algorithmique et programmation en

LANGAGE C
L1BCGS
2020-2021

1 FST L1BCGS
 Notion de procédure et de fonction
—  Bien souvent, lorsqu’on commence à écrire de long programme,
on se rend rapidement compte que certains blocs d’instructions
se répètent.
—  Une procédure ou fonction est un bloc d’instructions, ayant un
début et une fin, et identifié par un nom.
—  En langage C, des sous programmes regroupés dans des
bibliothèques standards peuvent être utilisés directement dans
n'importe quel programme. Par exemple, printf, scanf, clrscr,
sqrt, …
—  Mais le programmeur est souvent amené à écrire ses propres
sous-programmes.

2 FST L1BCGS
 Portée d’une variable
—  La portée d’une variable est l’ensemble des sous-
programmes où cette variable est connue
—  Une variable déclarée en dehors de tout sous-programme
est appelée variable globale. Sa portée est totale : le
programme principal et tous les sous-programmes peuvent
utiliser cette variable.
—  Une variable déclarée au sein d’un sous programme est
appelée variable locale. Sa portée est uniquement le sous-
programme où elle est déclarée.
—  Lorsque, dans un sous programme, le nom d’une variable
locale est identique à celui d'une variable globale, la
variable globale est localement masquée.
3
FST L1BCGS
 Durée de vie d’une variable
—  La durée de vie d’une variable est le temps pendant lequel
la variable existe, c’est-à-dire pendant lequel elle peut être
utilisée.
—  Elle commence par la réservation de sa place en mémoire
et s’arrête lorsque cette place est libérée.
—  Ainsi, une variable globale a la même durée que le
programme principal : elle est créée quand le programme
est lancé et est « détruite » quand le programme s’arrête.
—  Une variable locale à un sous-programme est créée quand
le sous-programme est appelé. Quand le sous-programme
est terminé, elle est détruite et la place qu’elle occupait est
récupérée.
4
FST L1BCGS
 Communication entre programme
et sous-programmes
—  Contrairement à un programme, un sous-
programme ne peut pas s'exécuter
indépendamment d'un autre programme. Le
programme qui utilise un sous-programme est
appelé programme appelant.
—  Un sous-programme peut être appelé soit par un
programme, soit par un autre sous-programme (qui
lui même a été appelé).

5 FST L1BCGS
 Paramètre formel et paramètre
effectif

—  Un paramètre est une variable particulière qui sert à la

communication entre programme appelant et sous -
programme.
—  Il est primordial de bien distinguer les paramètres qui se
trouvent dans l'en-tête d'un sous programme, lors de sa
définition et les paramètres (ou arguments) qui se trouvent
placés entre parenthèses lors de l'appel.
—  Les paramètres placés dans la définition d’un sous
programme sont les paramètres formels . Ils servent à
décrire le traitement à réaliser par le sous programme
indépendamment des valeurs traitées
6 FST L1BCGS
 Paramètre formel et paramètre
effectif

—  Les paramètres avec lesquels le sous programme est

effectivement appelé sont les paramètres effectifs ou
réels.
—  Lorsqu'il y a plusieurs paramètres dans la définition d’un
sous programme (paramètres formels) , il faut absolument
qu'il y en ait le même nombre à l'appel (paramètres
effectifs) et que l'ordre soit respecté.
—  Chaque paramètre effectif doit être de même type que le
paramètre formel auquel il correspond.

7 FST L1BCGS
 Passage de paramètres

—  Dans l’appel d’un sous programme, le programme

appelant fournit des paramètres effectifs
correspondants aux paramètres du sous programme
(paramètres formels). Il y a alors ce qu’on appelle un
passage de paramètres.
—  Le passage d’un paramètre peut se faire suivant deux
modes.

8 FST L1BCGS
 Passage de paramètre en entrée
—  Lors de l'appel du sous programme, la valeur du
paramètre effectif (passé en argument) est copiée
dans le paramètre formel. Le sous programme
effectue alors le traitement avec le paramètre
formel et n'utilise pas directement le paramètre
effectif.
—  Les instructions du sous-programme ne peuvent
donc pas modifier le paramètre fourni par le
programme appelant (paramètre effectif).

9 FST L1BCGS
 Passage de paramètre en entrée-
sortie
—  Ce mode de passage de paramètre est à utiliser lorsque
le sous-programme doit pouvoir utiliser et/ou modifier
la valeur du paramètre fourni par le programme
appelant.
—  Pour ce mode de passage on ne peut pas utiliser de
constante ou de valeur comme paramètre effectif.

10 FST L1BCGS
 Les fonctions
—  Les fonctions sont des sous-programmes qui retournent un
et un seul résultat au programme appelant à travers une
valeur de retour.
—  Une fonction possède un type : c’est le type de la valeur
retournée.
—  Les paramètres sont en nombre fixe (>=0).
—  Le passage de paramètres est uniquement en entrée : c’est
pour cela qu’il n’est pas précisé.
—  La valeur de retour est spécifiée par l’instruction
Retourner

11 FST L1BCGS
 Syntaxe de définition d’une
fonction :
—  Fonction nom_fonction (paramètre1 : type1, paramètre2 :
type2, …, paramètreN : typeN) : type_ valeur_retournée
—  variable
—  // déclaration des variables locales
—  Début
—  // traitement
—  …
—  Retourner expression
—  FinFonction

12 FST L1BCGS
 Exemple
Fonction factoriel(n: entier) : entier
variable
i : entier
fact : entier ………….
Début début
fact =1 Ecrire("Calcul du factoriel d’un entier :")
Si (n != 0) Alors Ecrire("Entrez un entier :")
Pour i = 1à n Faire Lire(x)
fact = fact * i Ecrire("Le factoriel de ",x," est ",factoriel(x))
FinPour fin
FinSi
Retourner fact
FinFonction

13 FST L1BCGS
 Les procédures
—  Une procédure est un sous programme qui n’a pas de
valeur de retour mais elle peut renvoyer plusieurs résultats
au programme appelant à travers des paramètres en entrée-
sortie. Elle peut aussi modifier la valeur d'un
paramètre passé en entrée-sortie.
—  Les procédures admettent des paramètres avec des
passages :
—  en entrée, préfixés par Entrée (ou E)
—  en entrée-sortie, préfixés par Entrée-Sortie (ou E-S)

14 FST L1BCGS
 Déclaration

—  On déclare une procédure de la façon suivante :

— 
—  Procédure nom de la procédure ( E paramètre(s) en
entrée, E-S paramètre(s) en entrée-sortie )
—  Variable
Procédure echanger (E-S a : Entier, b : Entier;)
—  // déclaration des variables locales
Variable
tmp : Entier
—  Début Début
—  // traitement tmp = a
a=b
—  … b = tmp
FinProcédure
—  FinProcédure
15 FST L1BCGS
 Syntaxe de définition d’une
fonction en Langage C
type nomFonction ( type1 paramètre1 , type2 paramètre2 , . . . , typeN
paramètreN)
{
// déclaration des variables locales
// traitement
…
return expression ;

}
int addition (int a, int b)
{
int somme; //déclaration de la variable locale
somme
somme = a + b;
return(somme);
}
16 FST L1BCGS
 Remarques
—  1) Il n’y a pas de procédure en C.
—  Pour traduire une procédure, on écrit une fonction qui a
comme type de retour le type void.
—  Cela permet de spécifier que la fonction ne renvoie aucun
résultat. Dans ce cas, pour terminer l'exécution de la
fonction, on peut utiliser le mot-clé return seul ou plus
simplement atteindre la fin des instructions.
—  2) Le programme principal en C est une fonction dont le
nom est main. Il peut avoir des paramètres ou non.

17 FST L1BCGS
 Passage de paramètres
—  Lors de l'appel d’une fonction, la valeur de chaque
paramètre effectif (paramètre passé en argument) est
recopiée dans le paramètre formel de la fonction qui va
travailler avec cette copie. La fonction ne va donc pas
modifier le paramètre effectif. On parle de passage de
paramètre par valeur.
—  Pour qu’une fonction modifie la valeur d’une variable, il
faut passer à la fonction non pas la variable elle même mais
son adresse en mémoire. On parle de passage de paramètre
par adresse.

18 FST L1BCGS
 FIN
19 FST L1BCGS