Cours sur les fonctions en C - Programmation

Ecole Supérieure des Sciences Appliquées d'Alger 2019/2020
Programmation en langage C 1ère année
Cours élaboré par : C. DIB 1 Les fonctions en C
Chapitre 2 : Les fonctions en C
1. Introduction :
Selon la complexité des problèmes à résoudre, un programme C peut dépasser une ou deux pages, nous
obtenons ainsi de longues listes d'instructions, peu structurées et par conséquent peu compréhensibles.
En plus, certaines suites d’instructions se répètent plusieurs fois dans le programme, ce qui entraîne un
gaspillage d’espace mémoire.
Pour bien structurer un programme C, le rendre plus lisible, plus compréhensible et plus fiable, on le
découpe en parties et sous p arties (en modules). Ces différentes parties s’appellent « fonctions ou actions
paramétrées ». Tout programme C contient obligatoirement une fonction principale main (), et p eut faire
appel à d’autres fonctions secondaires qui peuvent être soit des fonctions prédéfinies dans les
bibliothèques standards, et prêtes à utiliser (comme la fonction pow(), sqrt(), … de la bibliothèque
math.h), ou des fonctions définies par l’utilisateur que l’on va voir dans ce chapitre.
2. Déclaration et appel des fonctions en C :
2.1 Déclaration des fonctions avant main () :
Dans ce cas, la fonction tout entière, en-tête et corps, est déclarée avant la fonction principale main ().
Type_retour nom_fonction (type 1 p aramètre1, type 2 paramètre 2, … )
{ Déclaration des variables locales.
Les instructions.
return valeur_retour }
 L’appel d’une fonction se fait soit à travers l’affectation de son nom avec ses paramètres d’appel
(sans les types) dans une variable de même type de retour, ou à travers l’utilisation directe de son
nom avec ses paramètres d’appel dans une expression ou un affichage.
 L’ordre et le type des paramètres d’appel doivent concorder avec les paramètres de la déclaration.
Exemple 1 :
Ecrire un programme C qui calcule et affiche l’expression S =n !+m !+k !
S ol uti on 1 : (sans fonctions)
#include<stdio.h>
int main()
{ int n,m,k,i,fn=1,fm=1,fk=1;
do{ puts("Donnez un entier positif");
scanf("%d",&n); } while(n<0);
do{ puts("Donnez un entier positif");
scanf("%d",&m); } while(m<0);
do{ puts("Donnez un entier positif");
scanf("%d",&k); } while(k<0);
for(i=1;i<=n;i++) fn*=i;
for(i=1;i<=m;i++) fm*=i;
for(i=1;i<=k;i++) fk*=i;
printf("%d!+%d!+%d!=%d\n",n,m,k,fn+fm+fk);
return 0;}
En-tête de la fonction
Corps de la fonction

Ecole Supérieure des Sciences Appliquées d'Alger 2019/2020
Programmation en langage C 1ère année
Cours élaboré par : C. DIB 2 Les fonctions en C
Déclaration de la fonction « demander »
S ol uti on 2 : (avec les fonctions)
Dans cet exemple d’application qui s’avère facile à résoudre, on remarque que le nombre d’instructions
dépasse dix (10). En plus, certains blocs d’instructions se répètent trois fois. Il s’agit des blocs suivants :
Bloc d’instructions 1 :
do{ puts("Donnez un entier positif");
scanf("%d",&n);
} while(n<0);
Bloc d’instructions 2 :
for(i=1;i<=n;i++) fn*=i;
Chacun de ses deux blocs se répète trois fois pour effectuer un même traitement avec n, m et k.
Afin d’éviter cette répétition, on va définir une fonction secondaire pour chaque bloc, telle que :
La fonction qui remplace le bloc d’instruction 1 : Demander, introduire puis retourner un entier positif
int demander ( )
{ int a ;
do{puts("Donnez un entier positif");
scanf("%d",&a); } while(a<0);
return a ; }
La fonction qui remplace le bloc d’instruction 2 : Calculer et retourner la factorielle d’un entier
int factorielle (int x)
{ int i,f=1;
for(i=1;i<=x;i++) f*=i;
return f;}
Le programme principal appelant :
#include<stdio.h>
int demander()
{ int a ;
do{ puts("Donnez un entier positif");
scanf("%d",&a); } while(a<0);
return a; }
int factorielle (int x)
{ int i,f=1;
for(i=1;i<=x;i++) f*=i;
return f;}
int main()
{ int n,m,k;
n=demander();
m=demander();
k=demander();
printf("%d!+%d!+%d!=%d\n",n,m,k,factorielle(n)+factorielle(m)+factorielle(k));
return 0;}
• demane r est une fonction sans
p
aramètres.
• « a » est une variable locale à la fonction
(manipulée seulement l’intérieure de la fonction
damande r), et elle sert comme valeur de retour.
• factorielle est une fonction à un
p
aramètre entier « x ».
• « i, f » sont des variables locales à la fonction.
• La variable locale « f » sert comme valeur de retour.
Déclaration de la fonction « factorielle »
« n,m,k » sont les variables de la fonction
principale main(), c à d accessibles partout
dans le main().
Appel de la fonction «demander» trois(03)
fois et affectation de la valeur retournée dans
les variables n, m puis k.
Appel de la fonction «factorielle» trois(03)
fois directement dans printf. La valeur
retournée par chaque appel est directement
utilisée dans la somme des factorielles.

Ecole Supérieure des Sciences Appliquées d'Alger 2019/2020
Programmation en langage C 1ère année
Cours élaboré par : C. DIB 3 Les fonctions en C
Appel de la fonction « cub
e
»
dans la fonction printf .
2.2 Déclaration des fonctions après main () :
Dans ce cas, la fonction est déclarée à travers son prototype qui peut être placé avant ou dans la fonction
principale main (), et avant d’appeler la fonction. L’en-tête et le corps de cette fonction sont définis après
main (). Le prototype d’une fonction n’est que son en-tête (type avec ou sans noms des paramètres) suivi
d’un point-virgule (;).
Exemple 2 :
Ecrire un programme C qui permet de calculer le cube d’un réel donné à travers une fonction cube.
Solution (la fonction cube est déclarée et définit avant main())
#include<stdio.h>
double cube(float a) ;
int main()
{float n;
puts("Donnez une valeur reelle");
scanf("%f",&n);
printf("Le cube de %.3f est %.3f\n",n, cube(n));
return 0; }
double cube(float a)
{return a*a*a;}
2.3 Déclaration des fonctions dans un fichier externe :
On peut déclarer de nouvelles fonctions dans un fichier externe « nom_fichier_externe.c » autre que
celui de la fonction main (). Pour que la fonction principale main() puisse appeler une fonction se
trouvant dans un fichier externe, il faut inclure le nom de ce dernier tout au début du fichier appelant
(c’est-à-dire le fichier de main()) à travers :
• Cas 1 : #include “nom_fichier_externe.c” si les deux fichiers partage le même dossier ;
Ou
• Cas 2 : #include “<chemin d’accès> / nom_fichier_externe.c” si le fichier externe ne p artage
pas le même dossier que celui de main (). Le <chemin d’accès> est l’ensemble des dossiers
qu’il faut parcourir en partant de la racine (C : le disque dure p ar exemp le) jusqu’au dossier
contenant le fichier externe en question. Ces différents dossiers doivent être séparés par (/).
Exemple 3 :
Ecrire un programme C qui cherche le maximum et le minimum de deux entiers en utilisant des fonctions
secondaires enregistrées dans un fichier externe.
Solution
1. On commence par ouvre un nouveau fichier mes_fonctions d’extension .c dans un dossier (mes
documents par exemple). Dans celui-ci, on déclare les deux fonctions min et max.
2. On ouvre un autre fichier min_max d’ext ens ion .c dans le même dossier que le premier, et dans
lequel on va déclarer la fonction main ().
Déclaration de p rototype de la
fonction « cube » avant main ().
On peut aussi mettre le p rototype
dans main() mais avant d’appeler
la fonction « cube ».
Définition de la fonction
« cube » (en-tête et corps) après
main ().

Ecole Supérieure des Sciences Appliquées d'Alger 2019/2020
Programmation en langage C 1ère année
Cours élaboré par : C. DIB 4 Les fonctions en C
Fichier « mes-fonctions.c » Fichier « max_min.c »
Dossier commun
Remarque :
 Plusieurs instructions return peuvent apparaître dans une fonction. Le retour au programme
appelant sera alors provoqué par le premier return rencontré lors de l'exécution.
Dans l’exemple 3, chacune des deux fonctions min et max possède deux return. Lors de l’appel de ces
fonctions avec les valeurs de n et m, et selon l’évaluation de la condition de l’instruction if, un seul bloc
s’exécute, soit le bloc de « if » ou celui de « else ». Par conséquent, un seul return sera provoqué pour
interrompre immédiatement l’exécution de la fonction.
Important : Il est déconseillé, pour une fonction à plusieurs paramètres, de faire figurer les opérateurs
d’incrémentation ou de décrémentation (++ ou --) dans les paramètres d’appel.
3. Déclaration et appel des procédures en C :
Le langage C ne comporte pas à strictement parler le concept de procédure. Cependant, le programmeur
peut réaliser une procédure à l’aide d’une fonction qui ne retourne aucune valeur, et dans laquelle le type
de la variable retournée est remp lacé p ar le mot-clef void. Le corp s d’une p rocédure s’achève p ar
l’instruction facultative return. On peut appeler une procédure pour afficher le contenu d’une variable,
d’une expression, ou d’un message sur écran.
voi d nom_procédure (type 1 paramètre, type 2 paramètre 2, …… )
{ Déclaration des variables locales.
Les instructions.
[return ;] }
Exemple 4 :
Ecrire une fonction ou une procédure C qui permet d’afficher le nombre d’apparition d’une valeur val
dans une liste de N entiers introduits par l’utilisateur.
Solution : Ici, il s’agit bien d’implémenter une procédure car on veut afficher le nombre d’apparition de
val sans retourner ce nombre à la fonction main ().
int max(int a,int b)
{if (a>=b) return a;
else return b;
}
int min(int a,int b)
{if (a<=b) return a;
else return b;
}
#include<stdio.h>
#include"mes_fonctions.c"
int main()
{int n,m;
puts("Donnez deux entiers");
scanf("%d%d",&n,&m);
printf("Le maximum(%d,%d)=%d\n",n,m,max(n,m));
printf("Le minimum(%d,%d)=%d\n",n,m,min(n,m));
return 0;}
Corps de la
p
rocédure
En-tête de la
p
rocédure
Un retour sans valeur
(
facultatif
)

Ecole Supérieure des Sciences Appliquées d'Alger 2019/2020
Programmation en langage C 1ère année
Cours élaboré par : C. DIB 5 Les fonctions en C
• La procédure demandée est :
void affiche_apparition (int taille,int valeur)
{int i, a, nbr=0;
printf("Donnez les %d entiers de votre liste :\n",taille);
for(i=1;i<=taille;i++) { scanf("%d",&a);
if (a==valeur) nbr++; }
printf("La valeur %d apparait %d fois dans votre liste\n",valeur,nbr);
return; }
• Le programme appelant peut prendre l’une des formes suivantes :
Forme 1 : (Déclaration de la procédure, en-tête et corps, avant main() )
#include<stdio.h>
void affiche_apparition(int taille,int valeur)
{int i,nbr=0,a;
printf("Donnez les %d entiers de votre liste :\n",taille);
for(i=1;i<=taille;i++) { scanf("%d",&a); if (a==valeur) nbr++; }
printf("La valeur %d apparait %d fois dans votre liste\n",valeur,nbr);
return; }
int main()
{ int N, val;
do{ puts("Donnez une taille strictement positif pour votre liste d'entiers");
scanf("%d",&N); } while (N<=0);
puts("Donnez la valeur a rechercher dans votre liste");
scanf("%d",&val);
affiche_apparition(N, val);
return 0; }
Forme 2 : ( Déclaration du prototype avant ou dans main() et définition de la procédure après main() )
#include<stdio.h>
int main()
{ int N, val;
do{ puts("Donnez une taille strictement positif pour votre liste d'entiers");
scanf("%d",&N); } while (N<=0);
puts("Donnez la valeur a rechercher dans votre liste"); scanf("%d",&val);
void affiche_apparition(int taille,int valeur);
affiche_apparition(N,val);
return 0; }
void affiche_apparition(int taille,int valeur)
{int i,nbr=0,a;
printf("Donnez les %d entiers de votre liste :\n",taille);
for(i=1;i<=taille;i++) { scanf("%d",&a); if (a==valeur) nbr++;}
printf("La valeur %d apparait %d fois dans votre liste\n",valeur,nbr);
}
Déclaration de la
procédure (avec return)
avant main ().
Appel de la procédure
dans main ().
Déclaration du prototype de
la procédure dans main ()
mais avant l’appel.
Appel de la procédure dans
main () et après la
déclaration de son
prototype.
Définition de la procédure
(en-tête et corps sans
return), après main ().