Lorsqu’un programme comprend de nombreuses lignes de code, il est difficile, voire impossible de mettre toutes les instructions les unes `a la suite des autres dans le programme principal main. Le programme serait illisible, comprendrait trop de variables, etc. Pour cette raison, on d´ecompose les probl`emes en sous-probl`emes et le programme en sous-programmes qui r´esolvent les sous-probl`emes. En langage C, l’outil pour cr´eer des sous-programmes est la notion de fonction.
L’utilisation de quelques fonctions a d´eja ´et´e vue, par exemple avec celle pr´ed´efinie dans des biblioth`eques standard comme printf de< stdio >, sqrt de < math >, et main qui est un cas particulier de fonctions.
5.1 Qu’est-ce qu’une fonction ?
5.1.1 D´ efinition
Unefonctionest un bloc de code C ind´ependant, r´ef´erenc´e par un nom, qui r´ealise une tˆache pr´ecise et qui peut renvoyer une valeur au programme qui l’a appel´ee. Examinons cette d´efinition :
— Une fonction est r´ef´erenc´ee par un nom. Ce nom est unique et en l’introduisant dans le code source de votre programme, vous pouvez ex´ecuter le code de la fonction. Une fonction peut ˆetre appel´ee par une autre fonction.
— Une fonction est ind´ependante. Une fonction peut effectuer sa tˆache avec ou sans
´
echanges avec une autre partie du programme.
— Une fonction r´ealise une tˆache particuli`ere. La tache est l’unit´e de base du travail r´ealis´e par le programme. Cela peut ˆetre un tri, ou le calcul d’une racine carr´ee, d’une moyenne...
— Une fonction peut renvoyer une valeur au programme appelant. Quand ce pro-gramme appelle la fonction, le code de cette fonction est ex´ecut´e. Ces instructions peuvent renvoyer une information au programme.
Les fonctions sont donc des sous-programmes qui permettent d’effectuer un ensemble d’instruc-tions par simple appel de la fonction dans le corps du programme principal. Elles ont plusieurs avantages :
— Permettent d’organiser le codeet am´eliorer la lisibit´e des programmes.
— Facilitent la maintenance du code (il suffit de modifier une seule fois).
— Ces fonctions peuvent ´eventuellement ˆetre r´eutilis´ees dans d’autres programmes.
5.1.2 D´ eclaration d’une fonction
Une fonction doit ˆetre d´efinie avant d’ˆetre utilis´ee programme. La d´efinition d’une fonction s’appelled´eclaration. Le format g´en´eral d’une d´eclaration de fonction est de la syntaxe suivante :
type de donn´ee Nom De La Fonction(type1 argument1, type2 argument2,· · ·) {
liste d’instructions }
Quelques remarques compl´ementaires :
— type de donn´ee repr´esente le type de l’identificateur du param`etre de sortie.
— Si la fonction ne renvoie aucune valeur, on la fait alors pr´ec´eder du mot-cl´e void.
— Si aucun type de donn´ee n’est pr´ecis´e, le type int est pris par d´efaut.
— Le nom de la fonction suit les mˆemes r`egles que les noms de variables.
— Si une fonction n’a pas d’arguments, on peut d´eclarer la liste des arguments comme (void) ou simplement comme ().
Exemple :
#include<stdio.h>
/* Fonction affichant un caract`ere */
void affiche car(char car)
printf(”Veuillez entrer un caract`ere :”) ; c=getchar() ;
for(i=0 ;i<100 ;i++) affiche car(c) ; }
5.1.3 Appel des fonctions
L’appel d’une fonction se fait en ´ecrivant son nom, suivit d’une paire de parenth`eses contenant
´eventuellement une liste d’arguments effectifs.
Nom De La Fonction(argument effectif 1, argument effectif 2, · · ·) ;
L’ordre et le type des param`etres effectifs de la fonction doivent concorder avec ceux donn´es dans l’en-tˆete de la fonction. Les param`etres effectifs peuvent ˆetre des expressions. La virgule qui s´epare deux param`etres effectifs est un simple signe de ponctuation ; il ne s’agit pas de l’op´erateur virgule.
Cela implique en particulier que l’ordre d’´evaluation des param`etres effectifs n’est pas assur´e et d´epend du compilateur. Il est donc d´econseill´e, pour une fonction `a plusieurs param`etres, de faire figurer des op´erateurs d’incr´ementation ou de d´ecr´ementation (++ ou −−) dans les expressions d´efinissant les param`etres effectifs.
5.1.4 Prototype d’une fonction
On peut se contenter de d´eclarer le prototype d’une fonction (sans le corps) :
type de donn´ee Nom De La Fonction(type1 argument1, type2 argument2,· · ·) ; Le prototype d’une fonction est une description d’une fonction qui est d´efinie plus loin dans le programme. On place donc le prototype en d´ebut de programme (avant la fonction principale main()).
Contrairement `a la d´efinition de la fonction, le prototype n’est pas suivi du corps de la fonction (contenant les instructions `a ex´ecuter).
Le prototype est une instruction, il est donc suivi d’un point virgule. Voici quelquesexemples de prototypes :
void fonction1( int x, float y) ;
La fonction (qui s’appelle ”fonction1”) admet deux arguments : le premier de type entier et le second de type r´eel. Elle ne retourne aucune valeur.
float fonction2(int a, double c) ;
La fonction ”fonction2” admet deux arguments (tous deux entiers) et retourne un r´eel.
Si on veut laisser la d´eclaration (d´efinition) de la fonction `a la fin du programme, il faut absolument d´eclarer le prototype de la fonction avant main().
5.1.5 Renvoi d’une valeur par une fonction
Toute fonction qui n’est pas de type void, son corps doit obligatoirement comporter une instruction return. La g´en´eration du retour de fonction est provoqu´ee par l’appel de l’instruction return.
On utlise l’instructionreturn sous l’une des deux formes suivantes : return expression ;
return (expression)
— La valeur d’expression correspond `a la valeur que retourne la fonction et doit donc ˆetre de type type de donn´ee.
— Plusieurs instructions return peuvent apparaˆıtre dans une fonction. Le retour au pro-gramme appelant sera alors provoqu´e par le premier return rencontr´e lors de l’ex´ecution.
Exemple 1 :
/* Renvoit le produit de 2 entiers*/
int produit(int a, int b) {
return(a*b) ; }
Exemple 2 :
/* Renvoit le minimum de deux entiers*/
float min(float a, float b) {
if (a<b) return a ; else
return b ; }
Exemple 3 :
#include<stdio.h>
int maximum(int valeur 1, int valeur 2) {
printf(”entrez les deux valeurs :”) ; scanf(”%d % d”, &i1, &i2) ;
printf(” max des valurs : %d\n”, maximum(i1,i2)) ; return 0 ;
}
Dans ce programme, on suppose que l’utilisateur a entr´e les valeurs 5 et 46. La machine doit appeler la fonction printf de la ligne 16 et pour cela, chacun des arguments de la fonction doit ˆetre ´evalu´e.
L’ex´ecution passe alors `a la fonction maximum, `a ce niveau, on peut comprendre que la variable valeur1 prend la valeur de i1 (c’est-`a-dire 5) et la valeur valeur2 prend la valeur de i2 (c’est-`a-dire 46), du fait de l’appel de maximum(i1,i2). Apr`es l’ex´ecution de l’instruction if, la valeur de max sera 46.
A la ligne 9 on sort de la fonction maximum pour revenir `a l’appel fait par printf de la ligne 16.
Tous les param`etres de la fonction ayant ´et´e ´evalu’es (maximum(i1,i2) a ´et´e ´evalu´e `a 46), printf est ex´ecut´e et dans le format, «%d» est remplac´e par 46.
5.2 Variables globales et Variables locales
5.2.1 Variables globales
Une variable globale est une variable d´eclar´ee en dehors de toute fonction, au d´ebut du fichier,
`
a l’exterieur de toutes les fonctions et sont disponibles `a toutes les fonctions du programme.
En g´en´eral, les variables globales sont d´eclar´ees apr`es les instructions #include au d´ebut du programme. Elles sont syst´ematiquement permanentes.
Dans le programme suivant, n est une variable globale : Exemple :
#include<stdio.h>
Les variables d´eclar´ees dans un bloc d’instructions sont uniquement visibles `a l’int´erieur de ce bloc. On dit que ce sont des variables locales `a ce bloc. Il faut noter donc que les variables d´eclar´ees au sein d’une fonction seront locales `a celle-ci et n’auront de sens que dans le corps de la fonction. Par d´efaut, les variables locales sont temporaires.
Exemple
La variable lettre est d´efinie localement dans le bloc de la fonction HELLO. Ainsi, aucune autre fonction n’a acc`es `a la variable lettre :
void HELLO(void) {
char lettre ;
printf(”Introduisez une lettre : ”) ; scanf(”%c”,&lettre) ;
printf(”Bonjour vous avez tap´e %c \n”, lettre) ; }
Attention : Une variable d´eclar´ee `a l’int´erieur d’un bloc cache toutes les variables du mˆeme nom des blocs qui l’entourent.
Exemple
int FONCTION(int A) {
int X ; ...
X = 100 ; ...
while (A>10) {
double X ; ...
X *= A ; ...
} }
la premi`ere instruction X=100 se rapporte `a la variable du type int d´eclar´ee dans le bloc ext´erieur de la fonction ; l’instruction X*=A agˆıt sur la variable du type double d´eclar´ee dans la boucle while. A l’int´erieur de la boucle, il est impossible d’acc´eder `a la variable X du bloc ext´erieur.
5.3 R´ ecursivit´ e
Une fonction C est dite r´ecursive si elle fait appelle `a elle-mˆeme.
Exemple
La fonction suivante calcule la factorielle n ! d’un nombre n. On se base sur la relation de recurrence n ! = (n . 1) !cdot n
int FactorielleRecursive(int n) {
if (n<= 0) return 1 ; else
return n*FactorielleRecursive(n-1) ; /* appel recursif */
}
L’appel d’une fonction `a l’interieur d’elle-mˆeme est nomm´e appel recursif. Un appel r´ecursif doit obligatoirement ˆetre dans une instruction conditionnelle (sinon la r´ecursivite est sans fin).