Chapitre 7: LES FONCTIONS

7.1. Modularisation de programmes

7.1.1. La modularité et ses avantages
La plupart des langages de programmation nous permettent de subdiviser nos
programmes en sous-programmes (fonctions). A l'aide de ces structures nous pouvons
modulariser nos programmes.
Avantages
Quelques avantages d'un programme modulaire:
* Meilleure lisibilité
* Diminution du risque d'erreurs
* Dissimulation des méthodes
Lors de l'utilisation d'un module il faut seulement connaître son effet, sans devoir
s'occuper des détails de sa réalisation.
* Réutilisation de modules déjà existants
* Simplicité de l'entretien
Un module peut être changé ou remplacé sans devoir toucher aux autres modules du
programme.
* Favorisation du travail en équipe
* Hiérarchisation des modules
syntaxe
<TypeRés> <NomFonct> (<TypePar1> <NomPar1>, <TypePar2> <NomPar2>, ... )
• {
• <déclarations locales>
• <instructions>
• }
• double a;
• double som(double x,double y){
• double s;
• s=x+y;
• return(s);
}
• main(){
• double b,c,d;
• a=1.; b=5.; c=5;
• printf(« la somme est%e: »,som(a,b));
• d = 25. + som(a,b) + c*som(a,b);
• printf(« d = %e « ,d); }
7.2.Les variables locales et globales
7.2.1. Variables locales
Les variables déclarées dans un bloc d'instructions sont uniquement visibles à
l'intérieur de ce bloc. On dit que ce sont des variables locales à ce bloc.
7.2.2. Variables globales
Les variables déclarées au début du fichier, à l'extérieur de toutes les fonctions sont
disponibles à toutes les fonctions du programme. Ce sont alors des variables globales.
7.3. Déclaration et définition de fonctions
7.3.1. Définition d'une fonction
Dans la définition d'une fonction, on indique:
- le nom de la fonction
- le type, le nombre et les noms des paramètres de la fonction
- le type du résultat fourni par la fonction
- les données locales à la fonction
- les instructions à exécuter
Remarques
• Si une fonction ne fournit pas de résultat, il faut indiquer void (vide) comme
type du résultat.
• Si une fonction n'a pas de paramètres, on peut déclarer la liste des paramètres
comme (void) ou comme () .
• Le type par défaut est int;
• Il est interdit de définir des fonctions à l'intérieur d'une autre fonction.
• En principe, l'ordre des définitions dans le texte du programme ne joue pas de
rôle, mais chaque fonction doit être déclarée ou définie avant d'être appelée.
7.3.2. Déclaration d'une fonction
En C, il faut déclarer chaque fonction avant de pouvoir l'utiliser.
Déclaration : Prototype d'une fonction
• <TypeRés> <NomFonct> (<TypePar1>, <TypePar2>, ...);
• ou bien
• <TypeRés> <NomFonct> (<TypePar1> <NomPar1>, <TypePar2>
<NomPar2>, ... );
7.4. Renvoyer un résultat
Pour fournir un résultat en quittant une fonction, on dispose de l’instruction return:
L'instruction return <expression>; a les effets suivants:
- évaluation de l'<expression>
- conversion automatique du résultat de l'expression dans le type de la fonction
- renvoi du résultat
- terminaison de la fonction
7.5. Paramètres d'une fonction
7.5.1. Passage des paramètres par valeur
Les paramètres d'une fonction sont à considérer comme des variables locales qui sont
initialisées automatiquement par les valeurs indiquées lors d'un appel.
A l'intérieur de la fonction, on peut changer les valeurs des paramètres sans influencer
les valeurs originales dans les fonctions appelantes.
7.5.2. Passage de l'adresse d'une variable
Lorsqu’on veut modifier la valeur d’une variable passée comme paramètre effectif, il
faut transmettre l’adresse de cette variable.
La fonction appelée range l’adresse transmise dans une variable pointeur et la
fonction travaille directement sur l’objet transmis.
• void echange(int x,int y){
• int temp;
• printf("debut echange%d %d",x,y);
• temp=x;
• x=y;
• y=temp;
• printf("fin echange%d %d",x,y);}
• void main(void)
• { int a=5,b=9;
• printf("avant echange%d %d ",a,b);
• echange(&a,&b);
• printf("apres echange%d %d ",a,b);}
• void echange(int *x,int *y){
• int temp;
• printf("debut echange%d %d",*x,*y);
• temp=*x;
• *x=*y;
• *y=temp;
• printf("fin echange%d %d",*x,*y);}
• void main(void)
• { int a=5,b=9;
• printf("avant echange%d %d ",a,b);
• echange(&a,&b);
• printf("apres echange%d %d ",a,b);}
7.5.3. Passage de l'adresse d'un tableau à une dimension
Déclaration
Dans la liste des paramètres d'une fonction, on peut déclarer un tableau par le nom
suivi de crochets,
• <type> <nom>[]
• ou par un pointeur sur le type des éléments du tableau:
• <type> *<nom>
Utilisation d’une fonction :
L’utilisation se traduit par un appel à la fonction en mentionnant son nom suivi de
parenthèses renfermant éventuellement des paramètres effectifs.
Remarques
• Une fonction est automatiquement disponible à toute les fonctions qui suivent
sa définition.
• Une fonction ne peut être définie à l’intérieur d’une autre fonction.
 • L’utilisation se traduit par un appel à la fonction en mentionnant son nom
suivi des paramètres effectifs entre parenthèses.
• Les paramètres réels et formels (muets) doivent correspondre en nombre et en
type.
• La portée d’une variable: domaine de validité ou de visibilité ou d’utilisation.
• Une variable locale cache toutes les autres variables du même nom.
7.5.4. Passage de l’adresse d’un tableau à deux dimensions
<type> <nommatrice>[<dimension1>][<dimension2>];
Exemple
Écrire un programme qui lit et affiche une matrice calcule la somme des éléments
d’une ligne donnée
#define maxl 10
#define maxc 10
void saisie(int mat[maxl][maxc],int *m)
{
int i,j;
printf("donner la taille");
scanf("%d",m);
for(i=0;i<*m;i++)
for(j=0;j<*m;j++)
scanf("%d",&mat[i][j]);
}
void affich(int mat[maxl][maxc],int m)
{
int i,j;
for(i=0;i<m;i++)
{
for(j=0;j<m;j++)
printf("%d ",mat[i][j]);
printf(" \n");
}
}
int somme(int mat[maxl][maxc],int m,int i)
{
int j,som;
for(j=0,som=0;j<m;j++)
som+=mat[i][j];
return som;
}
void main(void)
{
int Nb;
int mat[maxl][maxc];
 saisie(mat,&Nb);
affich(mat,Nb);
printf("la somme est %d ",somme(mat,Nb,1));
}
Exercice
Écrire une fonction qui donne la première occurrence d’une valeur donnée
Écrire une fonction qui donne la dernière occurrence d’une valeur donnée
• int occurence(float *t,int n,float x)
• { int i;
• for(i=0;i<n;i++)
• if(t[i]==x)
• return i;
• return -1;
• }
• int occurencef(float *t,int n,float x)
• { int i;
• for(i=n-1;i>-1;i--)
• if(t[i]==x)
• return i;
• return -1;
• }
• void main(void)
• { float tab[max],x; int Nb,resultat;
• lecture(tab,&Nb);
• printf("donner la valeur cherchée :");
• scanf("%f",&x);
• resultat=occurencef(tab,Nb,x);
• if(resultat!=-1){
• printf("la derniere occ %d \n",resultat);
• printf("premiere occ%d\n",occurence(tab,Nb,x));
• }
• else
• printf("n'existe pas\n");
• }
Exercices d’application
• Écrire une fonction qui lit les éléments d’un tableau
• Écrire une fonction qui affiche les éléments d’un tableau
• #define max 100
• void lecture(float *tab,int *Nb)
• {int i;
• printf("entrez le nombre de notes a traiter :");
• scanf("%d",Nb);
• for(i=0;i<*Nb;i++) {
 • printf("valeur %d ? ",i+1);
• scanf("%f",&tab[i]);}
• }
• void afficher(float tab[],int Nb)
• { int i;
• for(i=0;i<Nb;i++)
• printf("%dieme note : : %f\n",i+1,tab[i]);
• }
• void main(void)
• { float tab[max];
• int Nb;
• lecture(tab,&Nb);
• afficher(tab,Nb);
• }
• void trie(float *t,int n)
• {
• int i,j,min;
• for(i=0;i<n-1;i++)
• {
• min=i;
• for(j=i+1;j<n;j++)
• if(t[min]>t[j])min=j;
• echange(&t[i],&t[min]);
• }
• }
7-6-fonctions récursives
6-1 définition
Une fonction est récursive si elle contient dans sa définition un appel à elle-même.
L’ordre de calcul est l’ordre inverse de l’appel de la fonction.
Exemple: calcul de la factorielle d’un entier:
• int fact(int n)
• {
if(n==0) return 1;
else
return (n*fact(n-1));
}
Procédé pratique:
• rechercher un cas trivial et sa solution
• décomposer le cas général en cas plus simples eux-aussi décomposables pour
aboutir au cas trivial.