Chapitre3
Les fonctions en C
Dr. Mounira Hmayda
[email protected]
Université Tunis-El Manar
Ecole Nationale d’Ingénieurs de Tunis, Département TIC ENIT
2021 - 2022
1
Les fonctions
• La définition d’une fonction peut figurer avant la fonction
principale main
• 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);
2
Déclarer une fonction
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.
3
Déclarer une fonction
TYPE de la valeur de retour 3 doubles comme paramètres
int print_table(double start, double end, double step)
{
double d;
Nom de la fonction
int lines = 1;
printf("Celsius\tFarenheit\n");
for(d = start; d <= end; d += step, lines++)
printf("%.1lf\t%.1lf\n", d, d * 1.8 + 32);
return lines;
}
Valeur renvoyée
4
Fonction, Programme et appel
#include <stdio.h>
Déclaration
void NomFonction ();
int main()
Fonction { int a, b, valmax;
principale
printf(“ Tapez deux entiers: “);
scanf(“%d %d”, &a, &b);
Appel
NomFonction ();
}
void NomFonction()
Définition
{ …………
} 5
Fonctions: Code retour
Cas 1: La fonction n'a pas de code retour:
1. Dans la fonction: void NomFonction(){ Rien ou return;}
• La fonction a le type void dans sa déclaration
• Aucune instruction return n'est nécessaire
2. À l'appel de la fonction: NomFonction ();
• L'appel de la fonction est une instruction
Cas 2: La fonction a un code retour:
1. Dans la fonction:
int NomFonction (){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
6
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);
Appel printf(“Maximum des deux valeurs: %d\n”, valmax);
int max( int v1, int v2)
{
int maximum;
Définition if (v1 > v2) maximum = v1;
else maximum = v2;
return maximum;
}
7
Passage de paramètres
Les VALEURS des paramètres effectifs sont copiées dans les paramètres
formels
int a, b, valmax; La valeur de a est copiée dans v1
... La valeur de b est copiée dans v2
valmax = max( a, b);
...
int max( int v1, int v2)
{
int maximum;
if (v1 > v2) maximum = v1; else L'appel de fonction prend comme
maximum = v2; valeur, la valeur renvoyée par
return maximum; l'instruction return
}
8
Passage des paramètres par valeur
* Quand une fonction est appelée, ses paramètres sont copiés
(passage par valeurs)
* La fonction travaille donc sur des copies des paramètres et
ne peut donc les modifier
* En C, le passage des paramètres par référence se fait en
utilisant des pointeurs (voir plus loin)
* scanf() travaille avec pointeur. C'est le pourquoi du &
9
Passage des paramètres par valeur
#include <stdio.h>
void change(int v);
void main(void)
{
int var = 5;
change(var); change: v = 500
main: var = 5
printf("main: var = %d\n", var);
}
void change(int v)
{
v *= 100;
printf("change: v = %d\n", v);
}
10
FONCTION RENVOYANT UNE VALEUR AU
PROGRAMME
#include <stdio.h>
int change(int v);
void main(void){
int var = 5;
int valeur;
valeur = change(var);
change: v =
printf("main: var = %d\n", var); main: var =
printf("main: valeur = %d\n", valeur); main: valeur =
}
int change(int v)
{
v *= 100;
printf("change: v = %d\n", v);
return (v+1);
}
11
Une fonction se termine et « rend la main » au code appelant lorsque son
exécution rencontre l’instruction : return expression; ou return;
#include <stdio.h>
int return_Val(int v);
void main(void){
int var = 5;
int valeur;
valeur = return_Val(var);
return_Val : rien
printf("main: var = %d\n", var); main: var =
printf("main: valeur = %d\n", valeur); main: valeur =
}
int return_Val(int v)
{
if (v == 10) return (2*v);
else return (3*v);
}
12
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 ;
}
int difference (int a, int b, int c) {
return (max (a, max(b,c)) - min (a, min (b, c))) ;
}
void main ()
{
printf ("%d", difference (10, 4, 7)) ;
}
13
Fonctions en C
Les principes
En C, tout est fonction (Définition, Déclaration et Appel).
Une fonction peut avoir autant de paramètres que l’on veut, même
aucun
(comme void main(void))
Une fonction renvoie une valeur ou aucune.
Les variables déclarées dans une fonction sont locales à cette fonction
Une fonction possède un et un seul point d'entrée, mais
éventuellement plusieurs points de sortie (à l'aide du mot return).
L'imbrication de fonctions n'est pas autorisée:
une fonction ne peut pas être déclarée à l'intérieur d'une autre fonction. Par contre, une
fonction peut appeler une autre fonction. Cette dernière doit être déclarée avant celle qui
l'appelle.
14
Une fonction est dite récursive, dès lors ou elle se fait appel pour
calculer une sous partie de la valeur finale qu'elle retournera.
#include <stdio.h>
int fact(int n);
int return_Val(int v);
void main(void){
int var = 5, int valeur;
valeur = return_Val(var);
printf("main: var = %d\n", var);
printf("main: valeur = %d\n", valeur); return_Val : rien
} main: var =
main: valeur =
int fact(int n) {
return (n<2?1:((int)n*fact(n-1));
}
int return_Val(int v)
{
if (v == 10) return (2*v);
else return fact(v);
}
15
L’opérateur ternaire “?:”
return(n<2?1:((int)n*fact(n-1));
Cet opérateur s’écrit: (condition) ? (instruction_1) : (instruction_2)
si la condition est vérifiée le bloc “instruction_1” est exécuté, sinon c’est le
bloc “instruction_2” qui l’est.
if (n<2 ) {
return 1;
} return(n<2?1:((int)n*fact(n-1));
else {
return ((int)n*fact(n-1));
}
16
Récursivité
• un programme est dit récursif s'il s'appelle lui même. Il
s'agit donc forcément d'une fonction.
• Puisqu'une fonction récursive s'appelle elle-même, il est
impératif de prévoir une condition d'arrêt à la récursion,
⇨ sinon le programme ne s'arrête jamais !!
• Il faut tester en premier la condition d'arrêt,
• Ensuite, si la condition n'est pas vérifiée, lancer un appel
récursif.
17
#include <stdio.h>
#include<conio.h>
int password;
void verifypassword();
int main()
{
verifypassword();
void verifypassword()
{
printf("entrer you password\n");
scanf("%d",&password);
if(password == 1234){
printf("welcom");}
else{
printf("woring password\n");
verifypassword();
}
}
18
Exercices
Exercices1
• Ecrire un programme qui permet de saisir deux
entiers, calculer leur somme et l’afficher
• Modifier le programme en ajoutant une fonction
somme qui calcule la somme et le retourne
Exercices2
Ecrire un programme C qui détermine le max de
quatre entiers à l'aide d'une fonction Max_4, et qui
doit utiliser une autre fonction Max_2 qui trouve le
max de deux entiers.
19
