CHAPITRE 5�� LANGAGE DE � PROGRAMMATION: C

F. Karami

Plan

1. Les Types Dérivés

​

• Les Fonctions

*

Programmer en langage C

2

���� II- Les Fonctions

*

Programmer en langage C

3

Les Fonctions

​

​

​

​

• Définition
• Exemple de définition et d’utilisation d’une fonction en C
• Exemple de fonction sans résultat
• Le cas des fonctions sans paramètres
• Règles
• Une fonction peut en appeler une autre
• En langage C, les paramètres sont transmis par valeur
• Passage de tableau en paramètre
• Passage de structure en paramètre
• Fonctions récursives
• Fonctions prédéfinies : math.h

*

Programmer en langage C

4

Définition

• Une fonction est un bloc de code C indépendant, référencé par un nom, qui réalise une tâche précise et qui peut renvoyer une valeur au programme qui l’a appelée :
• Une fonction est référencée par un nom: ce nom est unique et en l’introduisant dans la source de votre programme, vous pouvez exécuter le code de la fonction. une fonction peut être appelée par une autre fonction.
• Une fonction est indépendante : une fonction peut effectuer avec ou sans échanges avec une autre partie du programme.
• Une fonction réalise une tâche particulière : cela peut être l’envoi d’une ligne de texte vers l’imprimante, un tri, ou le calcul d’une racine carrée.
• Une fonction peut renvoyer une valeur au programme appelant: Quand ce programme appelle la fonction, le code de cette fonction est exécuté. Ces instructions peuvent renvoyer une information au programme.

​

​

*

Programmer en langage C

5

Les fonctions

Définition : Syntaxe

type identificateur ( liste de-déclarations-de-paramètres )

{

liste-de-déclarations_option(optionnel)

liste-d'instructions

}

​

• type identificateur ( liste-de-déclarations-de-paramètres );

🖝porte le nom de prototype de fonction.

​

*

Programmer en langage C

6

Les fonctions

Définition : Sémantique

• type :est le type de la valeur rendue par la fonction ;
• identificateur :est le nom de la fonction ;
• Liste de déclarations-de-paramètres : est la liste (séparés par des virgules) des déclarations des paramètres formels.
• La liste-de-déclarations_option : permet si besoin, de déclarer des variables qui seront locales à la fonction, elles seront donc inaccessibles de l'extérieur.
• La liste-d'instructions: est l'ensemble des instructions qui seront exécutées sur appel de la fonction. Parmi ces instructions, il doit y avoir au moins une instruction du type : return expression ;

*

Programmer en langage C

7

Les fonctions

Définition: Appel d’une fonction

• Syntaxe :
• Expression :

🡺 identificateur ( liste-d'expressions );

• Sémantique :
• Les expressions de liste-d'expressions sont évaluées, puis passées en tant que paramètres effectifs à la fonction de nom identificateur, qui est ensuite exécutée. La valeur rendue par la fonction est la valeur de l'expression appel de fonction.

​

*

Programmer en langage C

8

Les fonctions

Exemple de définition et d’utilisation d’une fonction en C

/*************** la fonction fexple ****************/

float fexple (float x, int b, int c){

float val ; /* déclaration d’une variable "locale" à fexple

val = x * x + b * x + c ;

return val ;

}

*

Programmer en langage C

9

Les fonctions

Exemple de définition et d’utilisation d’une fonction en C

#include <stdio.h>

/***** le programme principal (fonction main) *****/

main(){

/* déclaration de fonction fexple */

float fexple (float, int, int) ; /* prototype de la fonction fexple */

float x = 1.5 ;

float y, z ;

int n = 3, p = 5, q = 10 ;

/* appel de fexple avec les arguments x, n et p */

y = fexple (x, n, p) ;

printf ("valeur de y : %e\n", y) ;

/* appel de fexple avec les arguments x+0.5, q et n-1 */

z = fexple (x+0.5, q, n-1) ;

printf ("valeur de z : %e\n", z) ;

}

*

Programmer en langage C

10

Les fonctions

Exemple de définition et d’utilisation d’une fonction en C

/* définition de la fonction */

​

long cube(long x) { /* en-tête de la fonction cube*/

​

long x_cube; /* variable “locale” à la fonction cube */

x_cube= x*x*x;

return x_cube;

}

*

Programmer en langage C

11

Les fonctions

Exemple de définition et d’utilisation d’une fonction en C

#include<stdio.h>

/* déclaration de la fonction cube*/

long cube(long ); /* prototype de la fonction cube */

/****************************************************/

long input, reponse;

main(){

printf("entrez une valeur entière : ");

scanf("%ld",&input);

reponse=cube(input);

printf("\n\n le cube de %ld est %ld\n", input, reponse);

}

*

Programmer en langage C

12

Les fonctions

Exercice

Quels seront les résultats fournis par ce programme :

main(){ �int arrondi (float) ; /* prototype de la fonction arrondi */

float v1 = 1.6, v2 = 2.8 ;

int p ;

p = arrondi (v1) ; printf (“%d\n”, p) ;

p = arrondi (v2) ; printf (“%d\n”, p) ;

printf (“%d %d\n”, arrondi(v1+v2), arrondi(v1) + arrondi(v2) ) ;

}

int arrondi (float r)

{ float y ;int n ;

y = r + 0.5 ;

n = y ;

return n ;

}

*

Programmer en langage C

13

Les fonctions

Autre exemple

/*définition d’une fonction, nommée max, qui fournit en

résultat la plus grande des trois valeurs entières reçues en

paramètres*/

​

int max (int a, int b, int c){

int m ;

m = a ;

if ( b>m ) m = b ;

if ( c>m ) m = c ;

return m ;

}

*

Programmer en langage C

14

Les fonctions

Autre exemple

/*programme principal*/

main(){ �int max (int, int, int) ; /* prototype de notre fonction max */

int n, p, q, m ;

n = 3 ; p = 5 ; q = 2 ;

m = max (n, p, q) ;

printf (“max de %d %d %d : %d\n”, n, p, q, m) ;

m = max (5*n, n+p, 12) ;

printf (“valeur : %d\n” , m) ;

}

*

Programmer en langage C

15

Les fonctions

Exemple de fonction sans résultat

Soit la définition de fonction nommée optimist :

void optimist (int nfois){ �int i ;

for (i=0 ; i<nfois ; i=i+1)

printf (“il fait beau\n”) ;

}

• Son en-tête montre qu’elle comporte un paramètre entier (nommé nfois) ; cette fois, il est précédé du mot void qui indique que la fonction ne fournit pas de résultat.
• Si l’on examine les instructions du corps de la fonction, on constate qu’elles affichent un certain nombre de fois le même texte : il fait beau. Pour effectuer son travail, notre fonction a eu besoin d’une variable locale (i).

*

Programmer en langage C

16

Les fonctions

Exemple de fonction sans résultat

• Remarques:
• Aucune instruction return ne figure dans la définition de notre fonction.
• y = optimist (k) ; /* incorrect */
• l’appel de cette fonction ce fait à l’aide d’une instruction de la forme :

optimist (k) ; /* instruction simple provoquant

l’appel de optimist à laquelle on

transmet en paramètre, la valeur de k */

*

Programmer en langage C

17

Les fonctions

Exemple de fonction sans résultat

main(){

void optimist (int) ; /* prototype de la fonction optimist */

int n = 2, p = 1 ;

optimist (n) ;

optimist (p) ;

optimist (n+p) ;

}

void optimist (int nfois)

{ int i ;

for (i=0 ; i<nfois ; i=i+1)

printf (“il fait beau\n”) ;

}

*

Programmer en langage C

18

Les fonctions

Le cas des fonctions sans paramètres

• Si une fonction ne possède aucun paramètre, son en-tête et sa déclaration (prototype) doivent comporter le mot void, à la place de la liste des paramètres.
• Exemple :
• int fexple1 (void)
• Sa déclaration (prototype) serait:

int fexple1 (void) ;

• L’en-tête d’une fonction ne recevant aucun paramètre et ne fournissant aucun résultat est:
• void fexple2 (void)
• Son prototype est:
• void fexple2 (void) ;

*

Programmer en langage C

19

Les fonctions

Le cas des fonctions sans paramètres

• L’appel d’une fonction sans paramètres doit comporter des parenthèses vides.
• Exemple:
• L’appel de fexple1 s’écrira : fexple1()
• et non simplement : fexple1
• Exemple :

#include<stdio.h>

void affiche(void);

main(){ �affiche();�}

void affiche(void){

printf(‘’bonjour’’);�}

*

Programmer en langage C

20

Les fonctions

Règles

• Arguments muets et arguments effectifs
• Les noms des arguments figurant dans l’en-tête de la fonction se nomment des « arguments muets », ou encore « arguments formels » ou « paramètres formels » (de l’anglais : formal parameter). Leur rôle est de permettre, au sein du corps de la fonction, de décrire ce qu’elle doit faire.
• Les arguments fournis lors de l’utilisation (l’appel) de la fonction se nomment des « arguments effectifs » (ou encore « paramètres effectifs »).

*

Programmer en langage C

21

Les fonctions

Règles: L’instruction return

• L’instruction return peut mentionner n’importe quelle expression. Ainsi, nous pourrons définir la fonction fexple d’une manière plus simple :
• float fexple (float x, int b, int c){� return (x * x + b * x + c) ;}
• L’instruction return peut apparaître à plusieurs reprises dans une fonction, comme dans cet autre exemple :
• double absom (double u, double v){

double s ;

s = a + b ;

if (s>0) return (s) ;

else return (-s);

}

*

Programmer en langage C

22

Les fonctions

Règles : Prototype

• L’instruction de déclaration du prototype sert à fournir au compilateur les informations nécessaires à la traduction des différents appels de la fonction (sans qu’il dispose des instructions de définition de cette fonction).
• En ce qui concerne son emplacement, le prototype peut figurer :
• soit parmi les différentes déclarations situées au début d’une fonction (y compris main) ; il n’est alors connu que dans la dite fonction ; c’était le cas dans les exemples rencontrés jusqu’ici ;
• soit avant toutes les définitions de fonctions, à un niveau global (comme les variables globales dont nous parlerons un peu plus loin) ; dans ce cas, il est utilisable par toutes les fonctions du programme.

*

Programmer en langage C

23

Les fonctions

Règles : Initialisation des variables locales

• Les variables locales peuvent être initialisées lors de leur déclaration. Dans ce cas, il faut savoir que la valeur indiquée est placée dans la variable, non pas au moment de la compilation, mais à chaque appel de la fonction. Par exemple, avec cette définition :

void affiche (void){ � int n = 10 ;

printf (“%d”, n) ;

n = n + 1 ;

}

• on obtiendra l’affichage de la valeur 10, à chaque appel de affiche.

*

Programmer en langage C

24

Les fonctions

Une fonction peut en appeler une autre

• Rien n’empêche qu’une fonction appelle, à son tour, une autre fonction, comme dans ce canevas :

main(){

int f1 (float) ; /* prototype de f1 */

.....

f1 (...) ; /* appel de f1 */

.....

}

int f1 (float x){ �void f2 (int) ; /* prototype de f2 */

.....

Return(…);}

void f2 (int n) {

.....

}

*

Programmer en langage C

25

Les fonctions

En langage C, les paramètres sont transmis par valeur

main(){

void echange (int a, int b) ;

int n=10, p=20 ;

printf (“avant appel : %d %d\n”, n, p) ;

echange (n, p) ;

printf (“après appel : %d %d”, n, p) ;

}

void echange (int a, int b){� int c ;

printf (“début echange : %d %d\n”, a, b) ;

c = a ; a = b ; b = c ;

printf (“fin echange : %d %d\n”, a, b) ;

}

*

Programmer en langage C

26

Les fonctions

avant appel : 10 20

début echange : 10 20

fin echange : 20 10

après appel : 10 20

En langage C, les paramètres sont transmis par valeur

• La fonction echange reçoit deux valeurs correspondant à ses deux paramètres muets a et b. Elle effectue un échange de ces deux valeurs. Mais, lorsque l’on est revenu dans le programme principal, aucune trace de cet échange ne subsiste sur les paramètres effectifs n et p.
• En effet, lors de l’appel de echange, il y a eu transmission de la valeur des expressions n et p. On peut dire que ces valeurs ont été recopiées “localement” dans la fonction echange dans des

emplacements nommés a et b. C’est effectivement sur ces copies qu’a travaillé la fonction echange, de sorte que les valeurs des variables n et p n’ont, quant à elles, pas été modifiées. C’est ce qui explique le résultat constaté.

*

Programmer en langage C

27

Les fonctions

En langage C, les paramètres sont transmis par valeur

• Solutions :
• Transmettre en paramètre la “valeur” de l’“adresse” d’une variable. La fonction recevra, certes, toujours une copie de cette adresse, mais elle pourra éventuellement agir sur ce qui se trouve à cette adresse. Ceci est possible grâce aux “pointeurs”.
• Utiliser des “variables globales”.

*

Programmer en langage C

28

Les fonctions

Passage de tableau en paramètre

• Tableau à une dimension de taille fixe

main(){

int i ;

int t[5] = { 1, 1, 1, 1, 1 } ; /* initialisation du tableau */

void affiche (int [5]) ; /* prototype de la fonction affiche */

printf (“tableau t avant appel de affiche : ”) ;

for (i=0 ; i<5 ; i=i+1) printf (“%d ”, t[i]) ;

printf (“\n”) ;

affiche (t) ; /* appel de affiche, à laquelle on transmet en paramètre le tableau t */

printf (“tableau t après appel de affiche : ”) ;

for (i=0 ; i<5 ; i=i+1) printf (“%d ”, t[i]) ;

}

void affiche (int v[5]){ � int i ;

for (i=0 ; i<5 ; i=i+1)

v[i] = i+1 ;}

*

Programmer en langage C

29

Les fonctions

Passage de tableau en paramètre

• Tableau à une dimension de taille fixe
• Le mécanisme
• Pour le compilateur, un nom de tableau (par exemple t) est identique à son adresse, c’est-à-dire à l’adresse de son premier élément (ici, &t[0]) ;
• l’appel affiche (t) provoque la transmission à la fonction affiche, de la valeur du paramètre t c’est-à-dire en fait de l’adresse du tableau t (il y a bien toujours mécanisme de transmission par valeur, mais cette valeur se trouve être celle d’une adresse) ;
• dans la fonction affiche, à chaque appel, le symbole t est remplacé par sa “valeur”, c’est-à-dire en l’occurrence l’adresse reçue en paramètre ; ainsi, une affectation telle que : v[i] = 0 ; est traduite en : affecter au i-ème entier, à partir de l’adresse v, la valeur 0.

*

Programmer en langage C

30

Les fonctions

Passage de tableau en paramètre

• Tableau à deux dimensions de taille fixe

void mat (int t[5][4]){ �int i, j ;

for (i=0 ; i<5 ; i++)

for (j=0 ; j<4 ; j++)

t[i][j] = 1 ;

}

Voici quelques exemples d’utilisation de cette fonction :

main (){

int tab [5] [4] ;

mat (tab) ;

}

​

*

Programmer en langage C

31

Les fonctions

Passage de tableau en paramètre

• Tableau à deux dimensions de taille variable

​

• l’en-tête de mat pourra éventuellement ne pas préciser le nombre de lignes :
• void mat (int t[][3])
• En revanche, il n’est pas possible de l’écrire :
• void mat (int t[][])/* en-tête incorrect */

​

*

Programmer en langage C

32

Les fonctions

Passage de structure en paramètre

#include<stdio.h>

#include<conio.h>

struct data{

float montant;

char fnom[20];

char lnom[20];

}rec;

void affiche_rec(struct data x);

main(){

printf("Entrez le montant du don\n");

scanf("%f",&rec.montant);

printf("Entrez le nom et le prénom du donateur\n");

scanf("%s %s", rec.lnom,rec.fnom);

printf("**********************\n");

affiche_rec(rec);

}

void affiche_rec(struct data x){ �printf("\n le donateur %s %s a donné %.2f dh\n", x.lnom, x.fnom, x.montant);

}

*

Programmer en langage C

33

Les fonctions

Passage de structure en paramètre

#include<stdio.h>

#define MAX 4

struct personne{

int numero;

char nom[10];

} data[MAX]={{1,"Smith"},{2,"Jones"},{3,"Adams"},{4,"Wilson"}};

void affiche_str(struct personne [MAX]);

main(){

affiche_str(data);

}

void affiche_str(struct personne x[MAX]){

int i;

for(i=0; i<MAX;i++)

printf("%d \t %s \n", x[i].numero,x[i].nom);

}

*

Programmer en langage C

34

Les fonctions

Fonctions récursives

• Le langage C autorise la récursivité des appels de fonctions. Celle-ci peut prendre deux aspects :
• récursivité directe : une fonction comporte, dans sa définition, au moins un appel à elle-même,
• récursivité croisée : l’appel d’une fonction entraîne celui d’une autre fonction qui, à son tour, appelle la fonction initiale (le cycle pouvant d’ailleurs faire intervenir plus de deux fonctions).
• Exemple

long fac (int n){

​

if (n>1) return (fac(n-1)*n) ;

else return(1) ;

}

*

Programmer en langage C

35

Les fonctions

Fonctions prédéfinies : math.h

• Pour utiliser les fonctions de cette librairie, il faut inclure la librairie par la directive #include <math.h>

*

Programmer en langage C

36

Les fonctions

Fonctions prédéfinies : math.h

*

Programmer en langage C

37

Les fonctions