LES SOUS PROGRAMMES
Fonctions et procédures
Dr N. BAME
Introduction
• Lorsqu'un programme est long, on peut le
décomposer en plusieurs parties plus petites,
– en donnant un nom à chacune de ces parties, et en les
assemblant pour former le programme final.
• C'est le principe de la programmation modulaire,
qui repose sur l'écriture de sous-programmes.
Notion de sous programme
• Un sous-programme est, comme son nom l'indique, un
petit programme réalisant un traitement particulier qui
s'exécute à l'intérieur d'un autre programme.
• Les sous-programmes sont utilisés pour deux raisons
essentielles :
– quand un même traitement doit être réalisé plusieurs fois
dans un programme (ou qu'il est utilisé dans plusieurs
programmes)
• on écrit un sous-programme pour ce traitement et on l'appelle à
chaque endroit où on en a besoin.
• On évite ainsi de réécrire plusieurs fois le code du traitement.
– pour organiser le code, améliorer la conception et la
lisibilité des gros programmes.
• En effet, le découpage en sous-programmes permet de traiter
séparément les difficultés.
Rappel : structure d’un programme
• Un programme doit suivre la structure suivante :
Programme nom du programme
Définition des types
Définition des constantes
Déclaration de variables
Définition des sous-programmes
début
instructions du programme principal
fin
Fonctionnement
• 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é).
• Lorsque le processeur rencontre l'appel d'un sous-
programme, il arrête momentanément l'exécution du
programme appelant pour aller exécuter les instructions du
sous-programme.
• Quand il a terminé l'exécution du sous-programme, le
processeur reprend l'exécution du programme appelant là où
il s'était arrêté.
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.
– Les paramètres formels sont des variables locales au sous
programme, et à ce titre ils sont déclarés dans l'entête du
sous programme.
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
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.
– Passage de paramètre en entrée
– Passage de paramètre en entrée-sortie
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).
• Ce mode de passage de paramètre admet
l’utilisation d'une variable, d’une constante ou
d’une valeur comme paramètre effectif.
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
Types de sous programme
• Comme un programme, un sous programme
possède un nom, des variables, des instructions, un
début et une fin.
• En algorithmique, on distingue deux types de sous
programmes: les fonctions et les procédures.
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é.
• Lors de l’appel, on peut donc utiliser comme
paramètres des variables, des constantes, des
valeurs mais aussi des résultats de fonction.
• La valeur de retour est spécifiée par l’instruction
Retourner
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 de variables
Début
// traitement
…
Retourner expression
FinFonction
Syntaxe de définition d’une fonction
• Le résultat d'une fonction doit obligatoirement être
retourné au programme appelant par l'instruction
Retourner et correspond à la valeur d'une
expression.
• Pour récupérer la valeur retournée par la fonction,
l'appel d'une fonction doit obligatoirement se
trouver à l'intérieur d'une instruction (affichage,
affectation,…) qui utilise sa valeur.
• Dans l’appel, on précise le nom de la fonction suivi
des paramètres entre parenthèses.
– Les parenthèses sont toujours présentes même lorsqu’il
n’y a pas de paramètre.
Exemple
• Fonction qui retourne le factoriel d’un nombre
Fonction factoriel(n: entier) : entier
variable
i : entier
fact : entier
Début
fact =1
Pour i = 1 à n Faire
fact = fact * i
FinPour
Retourner fact
FinFonction
Exemple de programme
Programme calculFactoriel
Variable
x : Entier
Fonction fact(n: entier) : entier
Variable
i : entier
res : entier
Début
res = 1
Si (n !=0) Alors
Pour i = 1à n Faire
res = res * n
FinPour
FinSi
Retourner res
FinFonction
Début
Ecrire("Calcul du factoriel d’un entier :")
Ecrire("Entrez un entier :")
Lire(x)
Ecrire("Le factoriel de ",x," est ",fact(x))
fin
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)
Syntaxe
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
// déclaration de variables
Début
// traitement
…
FinProcédure
Exemple de déclaration de procédure
Procédure echanger (E-S a : Entier, b : Entier)
Variable
tmp : Entier
Début
tmp = a
a=b
b = tmp
FinProcédure
• On appelle une procédure en indiquant son nom suivi des
paramètres entre parenthèses.
• L'appel d'une procédure représente une instruction en elle-
même.
• On ne peut pas appeler une procédure à l'intérieur d'une
autre instruction.
Exemple de programme
Programme permutation
Variables
a : Entier, b : Entier
procédure echanger (E-S x : Entier, y : Entier)
Variable
tmp : Entier
Début
tmp = x
x=y
y = tmp
FinProcédure
début
Ecrire("Donnez l'entier a :")
Lire(a)
Ecrire("Donnez l'entier b :")
Lire(b)
Ecrire("Avant échange : a=",a," et b = ",b)
echanger(a,b)
Ecrire("Après échange : a=",a," et b = ",b)
fin
Portée d’une variable
• La portée d’une variable est l’ensemble des sous-programmes où
cette variable est connue
– les instructions de ces sous-programmes peuvent utiliser cette variable.
• 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éclare.
• 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. Dans ce sous-programme la variable globale
devient inaccessible.
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.
• Une variable a la même durée de vie que l’entité dans
laquelle elle a été déclarée.
• Ainsi, une variable globale a la même durée que le
programme : 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
libérée.
Choisir entre fonction et procédure
• Toute fonction peut s’écrire sous la forme d’une
procédure. La procédure correspondante prend un
paramètre formel de plus que la fonction. Le type
de ce paramètre est le type de retour de la fonction
et son mode de passage est en sortie.
• L’intérêt des fonctions par rapport aux procédures
est d’ordre syntaxique : elles sont plus faciles à
utiliser car elles peuvent apparaître dans une
expression.
• Si on veut, par exemple, les utiliser pour initialiser
une variable, il suffit de les utiliser avec l’affectation.
Les sous-programmes en C
• Syntaxe de définition d’une fonction
• On définit une fonction en respectant la syntaxe suivante :
typeRetour nomFonction ( type1 paramètre1 , type2 paramètre2 , . . . , typeN
paramètreN)
{
// déclaration des variables
// traitement
…
return expression ;
• L’instruction
return expression;
arrête l’exécution de la fonction et retourne comme résultat de la fonction
la valeur de l’expression.
• En langage C le type de retour du résultat d’une fonction est un type
simple, une structure ou bien un pointeur.
Exemple
• Fonction qui retourne la somme de deux entiers
int addition (int a, int b)
{
int somme; //déclaration de la variable locale somme
somme = a + b;
return (somme);
}
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.
Prototype d’une fonction
• On peut faire la déclaration d’une fonction en donnant son
prototype (ou signature) selon la syntaxe suivante:
type nomFonction ( type1, type2, . . ., typeN );
• Le prototype indique le type du résultat de la fonction, le nom
de la fonction et le type de chaque paramètre.
• Exemple: le prototype de la fonction addition définie
précédemment est:
int addition(int, int) ;
• Cette déclaration n’est pas obligatoire en C. Il suffit de donner
la définition de la fonction.
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.
– La fonction appelée copie cette adresse dans son paramètre
formel qui pointe alors sur cet emplacement mémoire.
– La fonction peut alors modifier le contenu de cet
emplacement mémoire (et donc le contenu de la variable
elle-même).
– On parle de passage de paramètre par adresse.
Exemple de passage de paramètre par valeur
int carre(int x)
{
return ( x*x ) ;
}
int main( )
{
int i = 3 ;
int j ;
j = carre (i) ;
printf ("%d" ,j) ;
}
Exemple de passage de paramètre par adresse
void miseAZero (int *p)
{
*p =0;
}
void main( )
{
int i = 3;
miseAZero (&i ) ;
printf ( "%d " , i ) ;
}
Le cas particulier des tableaux
• Le langage C permet de transmettre un tableau en
paramètre d'une fonction, mais avec une certaine
particularité :
– Un tableau est toujours passé en E-S.
– un tableau est toujours passé par adresse.
• Et pour cela, on n’a pas besoin de passer en
paramètre un pointeur sur la variable tableau.
• Il suffit seulement de passer en paramètre la
variable tableau elle même.
Exemple :
void raz(int tab[5]) //définition de la fonction void raz
{ for(int i = 0; i<5; i++)
tab[i] =0; sortie d'écran :
}
int main( ) tableau avant appel de raz
2 6 3 1 4
{
tableau après appel de raz
int i;
0 0 0 0 0
int t[5] = {2, 6, 3 , 1, 4};
printf(" tableau avant appel de raz\n") ;
for( i=0; i<5; i++)
printf(“%d ”, t[i]);
raz(t); //appel de la fonction avec le tableau en paramètre
printf("\ntableau après appel de raz");
for( i=0; i<5; i++)
printf(“%d ”, t[i]);
}
Remarque
• Il est possible d’avoir une fonction ayant comme
paramètre formel un tableau dont la taille n’est
pas précisée (crochets vides).
• Dans ce cas, la taille effective (ou le nombre
d'éléments utilisés) du tableau doit aussi être un
paramètre formel.
• Cela permet d’appeler une telle fonction avec des
tableaux de tailles différentes.
Exemple
Voilà comment on pourrait adapter la fonction raz définie
précédemment :
void raz(int tab[ ], int taille)
{
for(int i = 0; i<taille; i++)
tab[i] =0;
}
L'appel de cette fonction comporte alors deux paramètres: le
nom du tableau, puis sa taille.
Exemple
raz ( t, 5);
avec t un tableau d'entiers d'au moins 5 éléments.
On peut appeler cette fonction avec d'autres tableaux d’entiers
de taille différente:
Exemple
raz(t2, 10);
avec t2 un tableau d'entiers d'au moins 10 éléments.
Cas des structures
• Les structures, comme toutes variables, peuvent être
passées en paramètre d'une fonction.
• L'intégralité de la structure est passée en paramètre, ce
qui évite d'avoir à passer tous les champs un à un (cela
est possible car l'affectation globale entre deux
structures de même type est autorisée).
• Le mode de passage des structures est le même que
pour les variables simples (contrairement aux
tableaux):
– si le passage s'effectue par valeur, alors la structure
paramètre ne sera pas modifiée.
– si le passage s'effectue par adresse, alors la structure
paramètre pourra être modifiée.
