Ecole Supérieure de Technologie

de Safi
1ère année GIM - INFORMATIQUE

LES FONCTIONS EN C

A.SOULMANI
 Introduction

Ecrire un programme qui demande à l’utilisateur de saisir un

nombre réel puis calcule et affiche son carré.
Le résultat d’exécution de ce programme doit être comme suit:

****************************************
Saisir un nombre: 12 

Le carré de ce nombre est: 144

****************************************
 Introduction
#include <stdio.h>
int main()
{
double valeurLue;
int nb;
nb = 0;
while (nb < 40)
{
printf(‘*’);
nb++;
}
printf(" \n ");
printf (" Saisir un nombre: ");
scanf("%f",&valeurLue);
printf (" Le carré de ce nombre est: %f \n", valeurLue * valeurLue);
nb = 0;
while (nb < 40)
{
printf(‘*’);
nb++;
}
printf(" \n ");

return 0;
}
 Déclaration d'une fonction simple
#include <stdio.h>

void ligneEtoiles()
{
int nb = 0;
while (nb < 40)
{
printf(‘*’);
nb++;
}
printf(" \n ");
}

int main()
{
double valeurLue;
int nb;
ligneEtoiles();
printf (" Saisir un nombre: ");
scanf("%f",&valeurLue);
printf (" Le carré de ce nombre est: %f \n", valeurLue * valeurLue);
ligneEtoiles();
return 0;
}
 Utilisation de paramètres
Fonctions à un paramètre
#include <stdio.h>

void ligneCaracteres(char car)

{
int nb = 0;
while (nb < 40)
{
printf("%c", car);
nb++;
}
printf(" \n ");
}
int main()
{
double valeurLue;
int nb;
ligneCaracteres(‘*’);
printf (" Saisir un nombre: ");
scanf("%f",&valeurLue);
printf (" Le carré de ce nombre est: %f \n", valeurLue * valeurLue);
ligneCaracteres(‘+’);
return 0;
}
 Utilisation de paramètres
Fonctions à plusieurs paramètres

void ligneCaracteres(char car, int nbCar)

{
int i = 0;
while (i < nbCar)
{
printf("%c", car);
i++;
}
printf(" \n ");
}

Exemples d’appels dans main():

ligneCaracteres(‘*’, 40);

ligneCaracteres(‘+’, 50);
 Valeur de Retour
#include <stdio.h>
int main()
{
int val1, val2;
int valAbs1, valAbs2;

printf (" Saisir deux nombres: ");

scanf("%d %d",&val1, &val1);

if (val1 >= 0)
valAbs1 = val1;
else valAbs2 = -val1;

if (val2 >= 0)
valAbs2 = val2;
else valAbs2 = -val2;

printf (" Les valeurs absolues sont: %d ,%d",valAbs1,valAbs2);

return 0;
}
 Valeur de Retour
#include <stdio.h>
/* Autre version */
int ValeurAbsolue (int x) int ValeurAbsolue (int x)
{ {
int res; if (x >= 0) return x;
if (x >= 0) else return -x;
res = x; }
else res = -x;
return res;
}

int main()
{
int val1, val2;
int valAbs1, valAbs2;
printf (" Saisir deux nombres: ");
scanf("%d %d",&val1, &val1);
valAbs1 = ValeurAbsolue(val1);
valAbs2 = ValeurAbsolue(val2);
printf (" Les valeurs absolues sont: %d ,%d",valAbs1,valAbs2);
return 0;
}
Exercice d’application:
Ecrire une fonction nommée min qui prend en paramètre deux entiers et qui renvoie le plus petit
des deux. Utiliser cette fonction dans un programme qui lit 10 entiers saisis au clavier puis affiche
la valeur minimale saisie.
Solution:
- On lit la première valeur saisie par l’utilisateur et on la considère provisoirement comme valeur minimale
- A chaque nouvelle valeur, on conserve la plus petite parmi l’ancienne valeur minimale et la nouvelle valeur lue
#include <stdio.h>

int min( int valeur1, int valeur2)

{
if (valeur1 < valeur2) return valeur1;
else return valeur2;
}
int main(){
int valeurMin;
int valeurLue;
int nbValeursLues = 1;
printf(" Entrer une valeur entiere : ");
scanf("%d ",&valeurMin);
while (nbValeursLues <= 10)
{
printf(" Entrer une valeur entiere : ");
scanf(" %d ",&valeurLue);
valeurMin = min (valeurMin, valeurLue);
nbValeursLues ++;
}
printf(" Le min vaut : %d ", valeurMin);
return 0;
}
 Prototype d’une fonction
#include <stdio.h>

int min( int, int); /* prototype de la fonction */

int main(){
int valeurMin;
int valeurLue;
int nbValeursLues = 1;
printf(" Entrer une valeur entiere : ");
scanf("%d ",&valeurMin);
while (nbValeursLues <= 10)
{
printf(" Entrer une valeur entiere : ");
scanf(" %d ",&valeurLue);
valeurMin = min (valeurMin, valeurLue);
nbValeursLues ++;
}
printf(" Le min vaut : %d ", valeurMin);
return 0;
}

int min( int valeur1, int valeur2)

{ /* implémentation de la fonction */
if (valeur1 < valeur2) return valeur1;
else return valeur2;
}
 VARIABLES EN MEMOIRE
Stockage des variables en mémoire
❑ L’ordinateur réserve une place mémoire pour chaque variable déclarée.

❑ C’est à cet endroit que la valeur de la variable est stockée.

❑ L’ordinateur associe au nom de la variable, l’adresse de stockage.

Ainsi, pendant le déroulement du programme, quand il rencontre un
nom de variable, il va chercher à l’adresse correspondante la valeur en
mémoire.

Exemples:
i nom de la variable

int i = 5; 5 valeur de la variable

@1000 adresse de la variable

var
char var = ‘a’; ‘a’
11 @2000
 Portée des variables
#include <stdio.h> /* déclaration des bibliothèques */

int i,j; /* i,j,a,b et c sont des variables globales */

float a,b,c;

void f1(int k) { /* début de la fonction f1, f1 a un seul paramètre : k */

int s,t; /* variables locales à f1 */
... /* instructions de f1 qui peuvent accéder aux variables */
/* k,i,j,a,b,c,s et t */
} /* fin de la définition de f1 */

int f2(float x,float y) { /* début de la fonction f2, f2 a deux

paramètres : x et y */
float u,v; /* variables locales à f2 */
... /* instructions de f2 qui peuvent accéder aux variables */
/* x,y,i,j,a,b,c,u et v */
} /* fin de la définition de f2 */

int main() { /* début du main, il n'a pas de paramètre */

... /* instructions qui appellerons f1 et f2 sans avoir accès à */
/* leurs variables locales */
} /* fin de de main */
 Transmission d’Arguments à une fonction
Transmission par valeur
void permuter(int ,int );
main
void main()
{ a b
int a = 10;
int b = 20;
10 20
@2000 @2200
printf("Avant permuter:\t %d \t %d",a,b);
permuter(a,b); Avant permuter: 10 20
printf("Apres permuter:\t %d \t %d",a,b); Apres permuter: 10 20
}
permuter
void permuter(int x, int y)
{ x y
int temp; 20 10
temp = x;
x = y; @4000 @4100
y = temp; temp
printf("A la fin de permuter:\t %d \t 10
%d",x,y);
} @4150
A la fin de permuter: 20 10
13
 Transmission d’Arguments à une fonction
Transmission par adresse ou référence
void permuter(int* ,int* );
main
void main()
{ a b
int a = 10;
int b = 20;
20 10
@2000 @3200
printf("Avant permuter:\t %d \t %d",a,b);
permuter(&a,&b); Avant permuter: 10 20
printf("Apres permuter:\t %d \t %d",a,b); Apres permuter: 20 10
}
permuter
void permuter(int* x, int* y)
{ x y
int temp; 2000 3200
temp = *x;
*x = *y; @5000 @6250
*y = temp; temp
printf("A la fin de permuter:\t %d \t 10
%d",*x,*y);
} @7000
A la fin de permuter: 20 10
14
 ADRESSE d’un TABLEAU

❑ On rappelle que le nom d’un tableau est une constante qui

contient l’adresse du premier élément du tableau.

int tab[4] = {20,5,0,100};

tab tab[0] tab[1] tab[2] tab[3]

@2000 20 5 0 100
@2000 @2002 @2004 @2006
tab

i 0 1 2 3
tab[i] 20 5 0 100
&tab[i] 2000 2002 2004 2006

15
 Passage de tableau en paramètre
void AfficheTabEntiers(int tab[5]);

❑ Il est parfois plus intéressant de passer la taille du tableau en paramètre.

void AfficheTabEntiers(int tab[], int taille);

void AfficheTabEntiers(int tab[], int taille);

{
int i;
for (i=0; i < taille; i++)
{
printf ("%d\t" , tab[i]);
}
}
 Différence entre passage en paramètre d’une
variable de type simple et celui d’un tableau

❑ Lorsqu’on passe une variable de type simple à une

fonction, sa valeur est copiée avant d’être placée dans
une nouvelle variable.

❑ Lorsqu’on passe une variable de type tableau en

paramètre, son contenu n’est pas copié avant la
transmission.

❑ Si la fonction modifie certaines valeurs du tableau,

elles seront également modifiées pour le programme
appelant.
 Passage de tableau en paramètre
❑ Si on souhaite effectuer une copie d’un tableau avant de le transmettre
en paramètre, il faudra copier tous ses éléments un par un dans un
tableau de même taille.

int tab[5] = {1, 2, 3, 4, 5};

int tabCopie[5];
int i;
for (i=0; i < 5; i++)
{
tabCopie[i] = tab[i];
}
 Des exemples de fonctions avec les tableaux
void SaisirTab(int tab[], int taille) int SommeTab(int tab[], int taille)
{ {
int i; int somme = 0;
for (i = 0; i < taille; i++) int i;
{ for (i = 0; i < taille; i++)
printf(" Value %d: ", i+1); {
scanf("%d",&tab[i]); somme += tab[i];
} }
printf("\n"); return somme;
} }

void AfficherTab(int tab[], int taille)

{ float MoyenneTab(int tab[], int N)
int i; {
for (i = 0; i < taille; i++) float moyenne;
{ moyenne = (float) sommeTab(tab, N)/N;
printf("%d\t", tab[i]); return moyenne;
} }
printf("\n");
}
Des exemples de fonctions avec les tableaux

int MaxTab(int tab[], int taille) int MinTab(int tab[], int taille)
{ {
int i; int i;
int max = tab[0]; int min = tab[0];
for (i = 1; i < taille; i++) for (i = 1; i < taille; i++)
{ {
if (tab[i] > max) if (tab[i] < min)
max = tab[i]; min = tab[i];
} }
return max; return min;
} }

int main()
{
int myTab[100];
int nbElements = 10;
SaisirTab(myTab, nbElements);
AfficherTab (myTab, nbElements);
printf(" Somme des elements du tableau est : %d", SommeTab(myTab, nbElements));
printf(" Moyenne des elements du tableau est : %f", MoyenneTab(myTab, nbElements));
printf(" Max des elements du tableau est : %d", MaxTab(myTab, nbElements));
printf(" Min des elements du tableau est : %d", MinTab(myTab, nbElements));
return 0;
}
Utilisation de Bibliothèques de fonctions
Prototype de la fonction

int abs(int valeur);

Implémentation de la fonction

int abs(int valeur)

{
if (valeur >= 0) return valeur;
else return (-valeur);
}
 Exemple de Bibliothèques de fonctions
Projet: test_bibl_fonct_tab
Fichier d’en-tête: my_bib_fonctions_tab.h
void saisirTab(int [], int);
void afficherTab(int [], int);
int sommeTab(int [], int); Prototypes des fonctions de notre bibliothèque
float moyenneTab(int [], int);
int MaxTab(int [], int);
int MinTab(int [], int);
Fichier: main.c
Fichier: my_bib_fonctions_tab.c #include <stdio.h>
#include <stdio.h> #include <stdlib.h>

void saisirTab(int tab[], int taille) #include "my_bib_fonctions_tab.h"

{
int i; int main()
for (i = 0; i < taille; i++) {
{ int myTab[100];
printf("Value %d: \t", i+1); int nb = 10;
scanf("%d",&tab[i]); saisirTab(myTab, nb);
} afficherTab (myTab, nbElements);
printf("\n"); printf("Somme : %d \n", sommeTab(myTab, nb));
} printf("Moyenne : %f \n", moyenneTab(myTab, nb));
printf("Max : %d \n", MaxTab(myTab, nb));
void afficherTab(int tab[], int taille) printf("Min : %d \n", MinTab(myTab, nb));
{ return 0;
int i; }
-
-
-
Implémentation des fonctions de notre bibliothèque
 Bibliothèque standard du C
Bibliothèque standard de C

assert.h ctype.h errno.h float.h limits.h math.h signal.h stdio.h stdlib.h string.h time.h

Fichier d’en-tête Contenu

ctype.h Fonction de diagnostic permettant de déterminer le type d’un caractère.

errno.h Gestion des codes d’erreurs retournés par des fonctions de la bibliothèque.

float.h Définit les limites associées aux variables décimales.

limits.h Définit les limites associées aux variables entières et caractères.

math.h Fonctions mathématiques.

signal.h Transmission de signaux entre programmes (processus).

stdio.h Gestion des entrées/sorties et manipulation de fichiers.

stdlib.h Fonctions utilitaires diverses.

string.h Traitement des chaînes de caractères.

time.h Manipulation du temps.

 La Récursivité
Définition
La récursivité est le processus dans lequel une fonction s’auto-appelle
directement ou indirectement.

Exemples
Exemple 1: Auto-appel direct Exemple 2: Auto-appel indirect
int recFonction1(int x)
int recFonction1(int x) {
...
{ recFonction2(n);
... }
recFonction1(n); /* ****************** */
} int recFonction2(int x)
{
...
recFonction1(n);
}
 La Récursivité
Déroulement d’un programme faisant appel à une fonction récurrente

int fonct(int n)
{
if (n==1)
return 1;
else n = 1 fonct(1)
return 1 + fonct(n – 1);
}
n = 2 fonct(2)

int main()
{ n = 3 fonct(3)
int n = 3;
printf("%d", fonct(n));
main()
return 0; n = 3
}
PILE

Affichage: 3
 La Récursivité
Stratégie pour trouver le résultat d’un programme faisant appel à une fonction
récurrente:

fonct(3) ≡ 3
int fonct(int n)
{
if (n==1)
return 1 + fonct(2) ≡ return 3
return 1;
else
return 1 + fonct(n – 1); return 1 + fonct(1) ≡ return 2
}

int main() return 1

{
int n = 3;
printf("%d", fonct(n)); Affichage: 3
return 0;
}
 La Récursivité
Exercice 1
Quel est le résultat de sortie de ce programme?

int fonct(int n)
{
if (n==0) a. 4
return 1; b. 7
else c. 15
return 7 + fonct(n – 2); d. 12
}

int main()
{
printf("%d", fonct(4));
return 0;
}
 La Récursivité
Exercice 2
Combien de fois la fonction get() sera appelée dans ce programme?

void get(int n)
{
if (n < 1) return; a. 15
get(n – 1); b. 25
get (n – 3); c. 35
printf("%d", n); d. 45
}

int main()
{
printf("%d", get(6));
return 0;
}
 La Récursivité
Exercice 2
Combien de fois la fonction get() sera appelée dans ce programme?

void get(int n) get(6)

{
if (n < 1) return; get(5) get(3) +6 appels
get(n – 1);
get (n – 3);
get(4) get(2) +4 appels
printf("%d", n);
}
get(3) get(1) +2 appels

int main()
{ get(2) get(0)
printf("%d", get(6));
return 0; get(1) get(-1)
}

get(0) get(-2)

La réponse est donc b: 25

 La Récursivité
Stratégie pour implémenter une fonction récursive:
❑ Il faut trouver la relation de récurrence.
❑ Il faut trouver la condition de sortie de la fonction sinon boucle
infinie (pile saturée).

Application
Ecrire une fonction récursive factorielle() int factorielle(int n)
qui calcule la factorielle d’un entier. {
if (n == 0) return 1;
else return (n * factorielle(n – 1));
▪ Relation de récurrence: n! = n * (n-1)! }
▪ Condition de sortie: 0! = 1
int main()
{ int n = 5;
printf("%d", factorielle(n));
return 0;
}
 La Récursivité
Avantages et inconvénients

•Un appel de fonction prend plus de temps qu'une simple itération de boucle.
•Un appel de fonction peut utiliser une plus grande quantité de mémoire.
 La Récursivité
Avantages et inconvénients
 Les fonctions en algorithmique
Fonctions en C

❑ Fonctions sans type de retour void AfficherMessage();

int Factorielle(int );
❑ Fonctions avec type de retour float MoyenneTab(int [],int);
char Menu();
…

En Algorithmique

❑ Fonctions
❑ Procédures

33
 Les Procédures en algorithmique
Procédure Nom_Procédure (Nom_Paramètre : Type_praramètre;……) ;
Déclaration
Nom_variable : Type_variable ;
…
Début
…
Instructions ;
…
Fin ;

Algorithme essai;
Variable I, S : entier;

Procédure Somme ;
Debut /*Début de la Procédure*/
S := 0 ;
Pour I := 1 à 100
Faire S := S + I
FinPour ;
Ecrire ('La somme des 100 premiers nombres est', S) ;
Fin /*Fin de la Procédure*/

Debut /*Début de l’algorithme*/

34
Somme
Fin. /*Fin de l’algorithme*/
 Les Fonctions en algorithmique
Fonction Nom_Fonction (Nom_Paramètre : Type_praramètre;……): type_fonction ;
Déclaration
Nom_variable : Type_variable ;
…
Début
…
Instructions ;
…
Nom_Fonction := résultat
Fin ;

Algorithme essai;
Variable I, S : entier;

Fonction Somme : entier;

Debut /*Début de la Procédure*/
S := 0 ;
Pour I := 1 à 100
Faire S := S + I
FinPour ;
Somme := S
Fin /*Fin de la Procédure*/

Debut /*Début de l’algorithme*/

S := Somme
35 Ecrire ('La somme des ', N, 'premiers nombres est’, S) ;
Fin. /*Fin de l’algorithme*/
 Fin();

36