Chapitre 5 (Atelier de programmation) :

Les fonctions

I. Introduction
En langage C, les sous-programmes s’appellent des fonctions. L'imbrication de fonctions
n'est pas autorisée en C : une fonction ne peut pas être définie à l'intérieur d'une autre
fonction. Par contre, une fonction peut appeler une autre fonction.
Une variable connue uniquement d'une fonction ou de main() est une variable
locale.
Une variable connue de tout le programme est une variable globale.

II. Définition d’une fonction

Pour écrire une fonction C, il faut coder les instructions qu’elle doit exécuter en
respectant certaines règles syntaxiques. Ce code est appelé définition de la fonction. Ci
dessous est la syntaxe pour définir une fonction.
[type] nom (liste_typée_paramétres_formels) /*en-tête de la fonction*/
{
définition des variables locales
déclaration de fonctions supplémentaires
instructions
}
[type] : type de valeur de retour nom : nom de la fonction

III. Déclaration d’une fonction

La définition d’une fonction doit se faire hors de toute fonction et peut intervenir
n’importe où dans le programme. Les fonctions définies peuvent être appelées par le
programme principal (la fonction main()) ou par d’autres fonctions.
Une déclaration de fonction est obligatoire lorsqu’une fonction doit être utilisée. Une
déclaration de fonction fournit des indications sur le nom de la fonction, sur le type de
valeur retournée et sur les paramètres.

La syntaxe de déclaration de fonction est la suivante :

[type] nom (liste_typée_paramétres_formels) ;

IV. Appel à une fonction

L’appel à une fonction se fait dans le programme à travers une instruction dans laquelle
figure le nom de la fonction suivi d’une liste de paramètres (une liste peut être vide).

IV. 1. Fonctions ne renvoyant rien au programme et sans passage d’arguments

Une fonction ne renvoyant rien au programme est une Procédure de type void.

Exemple :
#include <stdio.h>
#include <conio.h>
void main( ) /* programme principal */
{
void carre(void) ; /* déclaration de la procédure */
clrscr();
carre( ); /* appel de la procédure */
getch( );}

void carre( ) /* définition de la procédure */

{
int n,n2; /* variables locales à carre */
printf("ENTRER UN NOMBRE: ");
scanf("%d",&n);
n2 = n*n ;
printf("le carré de %d est : %d\n",n,n2);
}

La déclaration de la fonction carre dans la fonction main est obligatoire puisque la

fonction carre est invoquée avant d’être développée.

IV. 2. Fonction renvoyant une valeur au programme et sans passage

d'arguments
Dans ce cas, la fonction ne possède pas de paramètre formel et après exécution, renvoie
une valeur. Le type de cette valeur est déclaré avec la fonction. La valeur retournée est
spécifiée à l'aide du mot réservé return.
Exemple :
#include <stdio.h>
#include <conio.h>
int n; /* variable globale, connue de tout le programme */
void main( ) /* programme principal */
{
int y ;
int carre(void) ; /* déclaration de la fonction */
clrscr();
y = carre( ); /* appel de la fonction */
printf(" LE CARRE EST %d \n", y);
getch( );
}
int carre( ) /* définition de la fonction */
{
int n2; /* variable locale */
printf("ENTRER UN NOMBRE: ");
scanf("%d",&n);
n2 = n*n;
return( n2) ;
}

La variable globale n est connue de tout le programme (fonctions et main( )).

La variable locale y n'est connue que de main( ).

IV. 3. Fonction avec passage d'arguments

Ces fonctions utilisent les valeurs de certaines variables du programme les ayant appelé :
on passe ces valeurs au moyen d'arguments déclarés avec la fonction.

Exemple :
#include <stdio.h>
#include <conio.h>
void main()
{
int carre(int) ; /* ou aussi int carre(int x) ; */
int n1, n2, res1, res2;
clrscr();
printf("ENTRER UN NOMBRE: ");
scanf("%d",&n1);
res1 = carre(n1);
printf("ENTRER UN AUTRE NOMBRE: ");
scanf("%d",&n2);
res2 = carre(n2);
printf("LES CARRES SONT: %d %d",res1,res2);
getch();
}
int carre(int x)
{
int x2;
x2 = x*x;
return(x2);
}

L’expression int carre(int) est appelée « prototype réduit » de la fonction.

L’expression int carre(int x) est appelée « prototype complet » de la fonction.
On peut ainsi appeler la fonction carre autant de fois que l'on veut avec des variables
différentes. Il est aussi à noter que x est un paramètre formel ou argument : ce n'est pas
une variable du programme. Par contre, n1 qui est une variable du programme, est un
paramètre effectif de la fonction carre.

V. Le passage de paramètres
Avec l’instruction return d’une part et la liste des paramètres d’autre part, une
fonction dispose de deux moyens pour communiquer ou pour échanger des données avec
d’autres fonctions.

V.1. Passage par valeur :

C’est le mode standard de transmission de paramètres effectifs à une fonction. La
fonction appelée reçoit une copie de la valeur de l’objet passé comme paramètre effectif.
Cette copie est affectée au paramètre formel correspondant.
La fonction appelée travaille seulement sur une copie du paramètre issu de la fonction
appelée. La fonction appelée peut modifier la valeur de la copie mais pas la valeur de la
variable d’origine.

V.2. Passage par adresse :

Lorsqu’on veut qu’une fonction puisse modifier la valeur d’une donnée passée comme
paramètre, il faut transmettre à la fonction non pas la valeur de l’objet concerné, mais
son adresse.

Exemple :
Fonction permettant d'échanger la valeur de 2 variables :

Syntaxe qui conduit à une erreur : PASSAGE DES PARAMETRES PAR VALEUR
#include <stdio.h>
#include <conio.h>
void permuter(int x,int y)
{
int temp;
temp= x;
x = y;
y = temp;
}
void main()
{
int a = 5 , b = 8;
clrscr();
permuter(a,b);
printf(« a=%d\n », a) ;
printf(« b=%d\n », b) ;
getch();
}

Syntaxe correcte : PASSAGE DES PARAMETRES PAR ADRESSE

Version 1 Version 2
#include <stdio.h> #include <stdio.h>
#include <conio.h> #include <conio.h>
void permuter(int *x,int *y) void permuter(int *x,int *y) ;
{ void main()
int temp; {
temp = *x; int a = 5 , b = 8 ;
*x = *y; clrscr();
*y = temp; permuter(&a,&b);
} printf(« a=%d\n », a) ;
void main() printf(« b=%d\n », b) ;
{ getch();
int a = 5 , b = 8 ; }
clrscr(); void permuter(int *x,int *y)
permuter(&a,&b); {
printf(« a=%d\n », a) ; int temp;
printf(« b=%d\n », b) ; temp = *x;
getch(); *x = *y;
} *y = temp;}
Dans la première version, la fonction permuter n’a pas à être déclarée dans la fonction
main puisqu’elle est développée avant sa première utilisation. Par ailleurs, la fonction
permuter, étant développée avant la fonction main dans la première version et déclarée
avant la fonction main dans la deuxième version, peut alors être invoquée sans problème
à partir de n’importe quelle autre fonction.

Application : Soit un programme permettant de saisir une suite de caractères qui se termine
par ‘#’. La saisie est réalisée caractère par caractère. Le programme calcule et affiche ensuite
le nombre total associé aux séparateurs (un caractère est dit séparateur s’il est un des
caractères suivant : ‘.’, ‘,’, ‘ ;’, ‘ :’, ‘ ?’, ‘ !’), caractères numériques, caractères alphabétiques
minuscules, caractères alphabétiques majuscules, autres caractères.
Correction :

#include<stdio.h>
#include<conio.h>

int est_num(char);
int est_maj(char);
int est_min(char);
int est_sep(char);

void main()
{
char c;
int nb_sep=0,nb_num=0,nb_car_min=0,nb_car_maj=0,nb_aut=0 ;
clrscr();

printf("Donner une suite de caractŠres qui se termine par #\n");

c=getche();

while(c!='#')
{
if(est_num(c))
nb_num++;

else if (est_min(c))
nb_car_min++;

else if (est_maj(c))
nb_car_maj++;

else if(est_sep(c))
nb_sep++;

else
nb_aut++;

c=getche();
}
printf("Le nombre de séparateurs est : %d\n",nb_sep);
printf("Le nombre de caractères numériques est : %d\n",nb_num);
printf("Le nombre de caractères alphabétiques miniscules est : %d\n",nb_car_min);
printf("Le nombre de caractères alphabétiques majuscules est : %d\n",nb_car_maj);
printf("Le nombre de caractères autres est : %d\n",nb_aut);

getch();
}

int est_num(char c)
{
return((c>='0')&&(c<='9'));
}

int est_min(char c)
{
return((c>='a')&&(c<='z'));
}

int est_maj(char c)
{
return((c>='A')&&(c<='Z'));
}

int est_sep(char c)
{
return((c=='.')||(c==',')||(c==';')||(c==':')||(c=='!')||(c=='?'));
}