Chapitre 07:

Les Fonctions en C
Niveau: 3B/2P
Date: 19-10-2020

1
Plan
• Notions basiques

• Passer des paramètres

• Localité des variables, passage par valeur et par adresse

2
Notions basiques

3
 Nous allons apprendre à…

1. Écrire une fonction

2. Appeler une fonction
3. Récupérer le résultat d’une fonction
4. Envoyer des données à une fonction
5. Recevoir des résultats d’une fonction

4
Définition
• La définition d’une fonction peut figurer après la
fonction principale main
▪ Ce qui nécessite sa déclaration précédemment
(prototype)

• Prototype
type_retour nom_fct(type arg1, type arg2…., type argn)
Syntaxes
Type du résultat Nom de la fonction Données et résultats

Type NomFonction (Liste_Paramètres)

{ Variables et constantes locales
Déclarations;
Traitement
Instructions;
Renvoi du résultat
return resultat;
}

Les paramètres sont optionnels. Les parenthèses sont obligatoires.

6
Programme, fonctions et appel
#include <stdio.h>

Déclaration
void NomFonction ();
void main()
{
int a, b, valmax;
Fonction
printf(“ Tapez deux entiers: “);
principale
scanf(“%d %d”, &a, &b);

NomFonction ();
…………………………..
}
Appel void NomFonction()
{

… ……………….
Définition
}

7
Exemple:
Paramètres formels
#include <stdio. h>
Déclaration
int max( int v1, int v2);
void main()
{
int a, b, valmax;
Fonction printf(“ Tapez deux entiers: “);
principale scanf(“%d %d”, &a, &b); Paramètres effectifs
valmax = max( a, b);
printf(“Maximum des deux valeurs: %d\n”, valmax);
}
Appel int max( int v1, int v2)
{
int maximum;
if (v1 > v2) maximum = v1;
else maximum = v2;
Définition return maximum;
}

8
Ecrire une fonction et l’appeler
#include <stdio.h> #include <stdio.h>
void Salutation ();
void Salutation () void main ()
{ {
Salutation ();
printf ("Bonjour\n"); }
} void Salutation ()
{
printf ("Bonjour\n");
void main () }
{
Salutation ();
}
9
Fonctions: Code retour
Cas 1: La fonction n'a pas de code retour: void NomFonction()
1. Dans la fonction: {
//Rien
• La fonction a le type void dans sa déclaration }
• Aucune instruction return n'est nécessaire
2. À l'appel de la fonction:
• L'appel de la fonction est une instruction NomFonction ();

Cas 2: La fonction a un code retour: int NomFonction ()

{
1. Dans la fonction:
return Valeur;
}

• La fonction a un type défini à sa déclaration

• La dernière instruction est un return d'une valeur de ce type
2. À l'appel de la fonction:
A = NomFonction ();
• La fonction est appelée dans une expression
Fonction avec retour
#include <stdio.h> #include <stdio.h>
void CalculerMoy (); void CalculerMoy ();
void main()
{ float SaisieNote ();
int i; void main()
for (i = 1; i<=50; i++)
CalculerMoy (); { int i;
} for (i = 1; i<=50; i++)
void CalculerMoy () CalculerMoy ();
{
float N1, N2, M; }
void CalculerMoy ()
printf ("Note 1: ");
scanf ("%f", &N1); { float N1, N2, M;
N1 = SaisieNote ();
printf ("Note 2: "); N2 = SaisieNote ();
scanf ("%f", &N2); M=(N1*0.8)+(N2*0.2);
printf (“Moyenne: %f", M);
M=(N1*0.8)+(N2*0.2);
}
printf (“Moyenne: %f", M); float SaisieNote ()
} { float X;
printf("Note:"); scanf("%f", &X);
return X;
}

11
Passer des paramètres

12
Principe
❖ Les VALEURS des paramètres effectifs sont copiées dans les paramètres formels
La valeur de a est copiée dans v1
int a, b, valmax; La valeur de b est copiée dans v2
...
valmax = max( a, b);
L'appel de fonction prend
... comme valeur, la valeur
int max( int v1, int v2) renvoyée par l'instruction
{ return
int maximum;
if (v1 > v2) maximum = v1;
else maximum = v2;
return maximum;
}

13 13
Exemple de transmission de données 1
int Fact (int x);
int main()
{
int A, F;
printf (“Entrez un entier positif:“); scanf(“%d”, &A);
F = Fact (A);
printf (“Factorielle de %d : %d”, A, F);
}

int Fact (int x)

{
int i, N = 1;
for (i = 1; i<=x; i++)
N = N * i;

return N;
}
14
Passer un tableau en paramètre
#include <stdio.h>
double MoyenneTableau (int v[], int Taille);
int main()
{
int Valeurs[4] = {2, 4, 3, 8}; Taille de v
float ValeurMoyenne;
ValeurMoyenne = MoyenneTableau (Valeurs, 4);
printf(“Moyenne: %f\n”, ValeurMoyenne);
}

Float MoyenneTableau (int V[], int Taille)

{
int i, Somme;
Somme = 0;
for (i = 0; i < Taille; i++)
{ Somme = Somme + V[i]; }
return (float)Somme / Taille;
}

15
Deuxième partie

16
Localité des variables, passage par valeur et par
adresse

17
Localité des variables
int main()
{
Visibles : a, b, valmax
int a, b, valmax;
NON visibles : maximum, v1, v2
printf(“ Tapez deux entiers: “);
scanf(“% d% d”, &a, &b);
valmax = max( a, b);
printf(“Maximum de ces deux valeurs: %d”, valmax);
}

int max( int v1, int v2)

{ Visibles : maximum, v1, v2
int maximum; NON visibles : a, b, valmax
if (v1 > v2) maximum = v1;
else maximum = v2;
return maximum;
}
18
Passage de paramètres
Copie des valeurs des paramètres effectifs dans les paramètres formels.

void main () A void F1 (int X)

{ B X {
int A; int Y;
int B; Y
A = 5; Y = X;
F1 (A);
B = A; X = 6;
} }

C'est la transmission de paramètres par copie de valeur.

19
Passage par valeur exemple :
void incremente (int val);
void main()
{
int v = 12;
incremente ( v); v vaut 12
printf (“v vaut %d”, v);
}
void incremente (int val)
{
val = val + 1;
}

20
Transmission par adresse
C'est l'adresse de v qui a été copiée

void main () v
{ Adr
int v = 12;
void incremente (int *Adr)
incremente (&v); {
} * Adr = *Adr + 1;
}

C'est la transmission de paramètres par adresse

21
Passage par adresse :
void incremente (int * val);
void main()
{
int v = 12;
incremente (&v); v vaut 13
printf (“v vaut %d”, v);
}
void incremente (int * val)
{
*val = *val + 1;
}

22
Passage d’adresses: utilité
• quand on doit modifier un paramètre
• quand on doit retourner plusieurs valeurs

23
Exemple
void incremente (int * Adr);
void main()
{
int v = 12;
int *pv;
Avant v = 12
pv = &v;
Après v = 13
printf (“Avant v = %d”, v);
incremente (pv);
printf (“Après v = %d”, v);
}
void incremente (int * Adr)
{
*Adr = *Adr + 1;
}

24
Transmission par adresse
C'est l’adresse pv qui a été copiée !

void main () v
{ Adr
int v = 12; pv
int * pv; void incremente (int *Adr)
{
pv = &v; *Adr = *Adr + 1;
incremente (pv); }
}

25
Exercice: écrire une fonction permettant de
permuter le contenu de deux variables ?
void permuter (int *A, int *B);
void main()
{
int x, y;
x = 5; y = 18;
permuter (&x, &y); x=18 et y=5
printf (“x = %d et y = %d”, x, y);
}
void permuter (int *A, int *B)
{
int C;
C = *A;
*A = *B;
*B = C;
} 26
Exercices ?
Que contiennent X, Y et Z à la fin de la fonction main () ?
void F2 (int A, int B, int * C);
void F3 (int K, int L, int * M);
X Y Z
void main ()
1 2 9
{ int X, Y, Z;
X= 1; Y = 2; Z = 9; X Y Z
F2 (X, Y, &Z); 1 2 7
}
void F2 (int A, int B, int * C) A B *C
{ 1 2 9
*C = 4;
F3 (A, B, C); A B *C
A = 4; 4 2 7
}
void F3 (int K, int L, int * M) K L *M
{ 1 2 4
K = 5;
K L *M
*M = K + L;}
5 2 7 27
Fonctions: résumé
Qu'il y ait code retour ou pas, une fonction peut avoir des
paramètres
• Transmission par copie de valeur pas d'altération
(donnée)
• Transmission par référence altération (donnée et résultat)
• Un paramètre donnée est transmis par valeur
• Un paramètre résultat est transmis par adresse

• Attention aux tableaux. Ils sont TOUJOURS (implicitement)

transmis par adresse.

28