Les fonctions

Les fonctions 1

1) Introduction

▪ On appelle fonction un sous-programme qui permet d'effectuer un ensemble d'instructions par simple appel de la fonction dans le corps

du programme principal.

▪ Les fonctions permettent d'exécuter dans plusieurs parties du programme une série d'instructions,

→ cela permet une simplicité du code et donc une taille de programme minimale.

▪ Une fonction peut faire appel à elle-même, on parle alors de fonction récursive.

▪ Généralement, une fonction retourne une valeur qui est le résultat de l'exécution de son code.

→ Il est possible en C/C++ de définir des fonctions qui ne retournent aucune valeur.

→ De telles fonctions sont équivalentes aux procédures définies en algorithmique.

1
 Les fonctions 2

2) Déclaration

► Déclaration d'une fonction

▪ La déclaration d'une fonction se fait comme suit:

➢ Syntaxe :
Type NomFonction (Type1 NomArg1,…, Type_n NomArg_n) ;

Avec : Type désigne le type de la valeur retournée par la fonction

Type_i NomArg_i désignent respectivement le type et le nom du ième argument de la fonction

➢ Exemple :

int f (int i, int j); // déclaration d’une fonction nommée f qui retourne un entier et qui a comme paramètres (i et j) de type entier

Les fonctions 3

2) Déclaration

► Déclaration du prototype d'une fonction

▪ Le prototype d'une fonction est une description d'une fonction qui est définie plus loin dans le programme.

▪ Cette description permet au compilateur de « vérifier » la validité de la fonction à chaque fois qu'il la rencontre dans le programme

▪ On place donc le prototype en début de programme (avant la fonction principale main())

▪ La déclaration se fait de la manière suivante:

➢ Syntaxe :
Type NomFonction (Type1,…, Type_n) ;

indications : →le prototype n'est pas suivi du corps de la fonction

→ il ne comprend pas le nom des paramètres (seulement leur type)

➢ Exemple :

int f (int , int ); // déclaration du prototype d’une fonction f qui retourne un entier et qui a deux paramètres de type entier

2
 Les fonctions 4

3) Définition

▪ La partie définition d'une fonction correspond au corps de la fonction.

▪ Il s'agit donc de la spécification de l'ensemble des instructions dont l'exécution réalise la tâche assurée par la fonction.

▪ La déclaration se fait de la manière suivante:

➢ Syntaxe :
Type NomFonction (Type1 NomArg1,…, Type_n NomArg_n) {
Déclarations des variables locales;
instruction_1
…
instruction_n
return valeur ;
}

Indication : Les variables locales ne peuvent être utilisées qu'à l'intérieur de la fonction. Elles ne sont pas visibles à l'extérieur.

Les fonctions 5

4) Type d'une fonction et valeur de retour

▪ Le type de la fonction indique le type de sa valeur de retour.

▪ Si aucun type n'est spécifié pour une fonction alors cette dernière est considérée par défaut comme étant de type int.

▪ L'instruction return provoque un arrêt immédiat de l'exécution des instructions du bloc associé à la fonction.

→ Elle permet de renvoyer une valeur à l'extérieur de la fonction en utilisant la syntaxe suivante :

return (valeur) ; Indication : L'utilisation des parenthèses avec return est facultative.

▪ Si l’instruction return est absente du corps d'une fonction, alors le programme continue son exécution des instructions jusqu'à l'accolade
fermant.
▪ La valeur renvoyée par return doit être du même type que celui de la fonction.

3
 Les fonctions 6

4) Type d'une fonction et valeur de retour

▪ Elle peut être exploitée comme n'importe quelle autre valeur du même type.

▪ Par exemple, elle peut être récupérée et stockée dans une variable de la manière suivante :
int var;
….
var = NomFonction (arg1, arg2, arg3…);

▪ Suite à une exécution une fonction ne peut retourner qu'une seule valeur et pas plus.

➢ Stratégie 1 : La déclaration de la fonction avant sa première utilisation (avant main()) et la définition après le programme principal

➢ Stratégie 2 : La déclaration et la définition de la fonction avant sa première utilisation ( avant le programme principal main() )

Les fonctions 7

4) Type d'une fonction et valeur de retour

▪ Exemple d’application de la stratégie 1 :

#include <iostream>
using namespace std;

int somme (int , int ); // déclaration de la fonction somme

int main(){
int s ; // déclaration d’une variable s qui va recevoir la valeur retournée par la fonction somme
s= somme (5,4); // Appel de la fonction somme
cout<< "somme = " << s ; // Affiche somme = 9
return 0;
}
int somme (int a , int b){ // définition de la fonction somme
return a+b;
}

4
 Les fonctions 8

4) Type d'une fonction et valeur de retour

▪ Exemple d’application de la stratégie 2 :

#include <iostream>
using namespace std;

int somme (int a , int b){ // déclaration et définition de la fonction somme

return a+b;
}
int main(){
int s ; // déclaration d’une variable s qui va recevoir la valeur retournée par la fonction somme
s= somme (5,4); // Appel de la fonction somme
cout<< "somme = " << s ; // Affiche somme = 9
return 0;
}

Les fonctions 9

4) Type d'une fonction et valeur de retour

▪ Il est possible d’avoir une fonction sans valeur de retour (procédure).

▪ Par exemple, si on veut définir une fonction qui prend comme paramètre un nombre et qui affiche un message indiquant si ce nombre est

strictement positif, strictement négatif ou nul.

#include <iostream> int main(){

using namespace std; Signe (5); // Appel de la fonction Signe
void Signe (int n ){ // déclaration et définition de la fonction Signe return 0;
if (n>0) }
cout << "Positif " ;
else if (n<0)
cout << "négatif " ;
else
cout << "null " ;
}

5
 Les fonctions 10

5) Fonction locale et fonction globale

► Fonction locale

▪ Tout comme les variables, une fonction peut être déclarée en C à l'intérieur d'un bloc (éventuellement une fonction) ou à l'extérieur.

▪ Si la déclaration est faite à l'intérieur alors la fonction est considérée comme locale à ce bloc et ne peut être appelée en dehors de celui-ci.

➢ Exemple :

En C (Possible) En C++ (N’est pas possible ➔ Erreur)

#include <stdio.h> #include <iostream>
using namespace std;
int main(){ int main(){
int somme (int a, int b ){ // déclaration et définition de la fonction somme int somme (int a, int b ){ // déclaration et définition de la fonction somme
return a+b ; return a+b ;
} }
somme (5,4); // Appel de la fonction somme somme (5,4); // Appel de la fonction somme
return 0; return 0;
} }
// Vous ne pouvez pas définir de fonctions à l'intérieur d'une autre fonction

Les fonctions 11

5) Fonction locale et fonction globale

► Fonction globale

▪ Une fonction est dite globale, si elle est déclarée en dehors de tout bloc.

▪ Elle peut être dans ce cas appelée de n'importe qu'elle endroit du programme.

➢ Exemple :

#include <iostream> int main(){

using namespace std; int id ; float n_ds ; float n_ex ;

float moyenne (float n_ds , float n_ex ){ // déclaration et définition de la fonction moyenne cout<< " Donner id = " ;

return (n_ds+(n_ex*2))/3; cin >> id ;

} cout<< "Donner une note de DS = " ;

void resultat (int id, float n_ds , float n_ex ){ // déclaration et définition de la fonction résultat cin >> n_ds ;

float res ; res = moyenne (n_ds , n_ex ); cout<< "Donner une note de l’examen = " ;

if ( res >=10) cin >> n_ex ;

cout << "L'étudiant possédant l’id : " << id << " a réussi la matière " ;
else resultat (id, n_ds , n_ex ) ;

cout << "L'étudiant possédant l’id : " << id << " a échoué la matière " ; return 0 ;

} }

6
 Les fonctions 12

6) Les catégories des paramètres des fonctions

► Paramètres formels et paramètres effectifs

▪ Deux types de paramètres de fonctions peuvent être distingués : les paramètres formels et les paramètres effectifs.

➢ Les paramètres formels :

#include <iostream>

→ sont ceux qui figurent dans la définition de la fonction. using namespace std; Paramètres formels

→ Ils sont utilisés dans les instructions faisant partie du bloc de la fonction et là seulement. int somme (int a , int b){
return a+b ;
→ Ces paramètres sont considérés comme des variables locales à la fonction.
}

➢ Les paramètres effectifs : int main(){

int s, x , y ; Paramètres effectifs
→ sont ceux qui figurent dans l'instruction d'appel de la fonction. cin>> x >> y ;
s= somme (x, y);
→ Ils sont substitués aux paramètres formels au moment de cet appel.
cout<< "somme = " << s ;
return 0;
}

Les fonctions 13

6) Les catégories des paramètres des fonctions

► Paramètres formels et paramètres effectifs

▪ NB: Les paramètres formels et effectifs doivent s'accorder en nombre, ordre et type.

➢ Exemple:

int main(){
#include <iostream>
int s, x , y, z=10 ;
cin >> x ;
int somme (int a , int b){
cin >> y ; Le compilateur va afficher un message d’erreur :
return a+b ;
s= somme (x, y, z); error: too many arguments to function ‘somme’
}
cout<<"somme ="<<s ; → Les paramètres formels et effectifs doivent s'accorder en nombre
return 0;
}

7
 Les fonctions 14

6) Les catégories des paramètres des fonctions

► Différents types des paramètres formels

▪ Suivant le rôle qu'ils assurent dans la fonction, les paramètres formels peuvent être classés en trois catégories :

1. Les paramètres données

2. Les paramètres résultats

3. Les paramètres données-résultats

Les fonctions 15

6) Les catégories des paramètres des fonctions

► Différents types des paramètres formels

▪ Suivant le rôle qu'ils assurent dans la fonction, les paramètres formels peuvent être classés en trois catégories :

1. Les paramètres données

→ Un paramètre "donnée" est une donnée nécessaire pour réaliser la tâche associée à la fonction.

→ Il ne subit aucune modification au cours de l'exécution de la fonction.

Exemple : Les paramètres a et b de la fonction somme sont des paramètres données.

…
int somme (int a , int b){
return a+b ;
}
….

8
 Les fonctions 16

6) Les catégories des paramètres des fonctions

► Différents types des paramètres formels

▪ Suivant le rôle qu'ils assurent dans la fonction, les paramètres formels peuvent être classés en trois catégories :

2. Les paramètres résultats

→ Un paramètre "résultat" est une variable qui est destinée à contenir le résultat de l'action de la fonction.

→ Sa valeur n'est pas significative avant le début.

Exemple : Le paramètre triple de la fonction calculerTriple est un paramètre résultat.

int CalculerTriple (int a , int triple){ int CalculerTriple (int a ){

Généralement un paramètre "résultat" n'a pas
triple = 3 * a ; int triple ;
besoin d'être déclaré comme argument de la
return triple ; triple = 3 * a ;
fonction, mais plutôt comme une variable locale
} return triple ;
…. }
….

Les fonctions 17

6) Les catégories des paramètres des fonctions

► Différents types des paramètres formels

▪ Suivant le rôle qu'ils assurent dans la fonction, les paramètres formels peuvent être classés en trois catégories :

3. Les paramètres données-résultats

→ Un paramètre "donnée-résultat" est à la fois une donnée et un résultat.

→ Il sert à passer une donnée à la fonction et que cette dernière modifie sa valeur.

Exemple : Les paramètres a et b de la fonction Permutation sont des paramètres données-résultats.

…
void Permutation (int &a , int &b){
int aux ;
aux = a ; a=b ; b=aux ;
}
….

9
 Les fonctions 18

7) Modes de passage des paramètres

► Passage par valeur

▪ C'est le mode de passage d'arguments le plus courant en C/C++ et le plus simple également.

▪ Dans ce mode, les valeurs des arguments au moment de l'appel (paramètres effectifs) sont recopiées dans les éléments de données locaux

correspondants à la fonction (paramètres formels).

▪ Après la sortie de la fonction, les valeurs des paramètres effectifs restent identiques à celles qu'ils avaient avant l'exécution de la fonction.

→ Ce mode de passage est adapté aux paramètres de type "données"

→ Pour les paramètres de type "résultat" ou "donnée-résultat", ce mode ne permet pas de récupérer les éventuelles modifications

effectuées au sein de la fonction.

Les fonctions 19

7) Modes de passage des paramètres

► Passage par valeur

▪ La déclaration d'un passage par valeur s'effectue de la manière suivante :

➢ Syntaxe :

TypeFonction NomFonction (……, Type ParamValeur,…);

// TypeFonction : Le type de la valeur retournée par la fontion (int, char, void,…)

// NomFonction : Nom de la fonction

// Type : Le type du paramètre passé par valeur

// ParamValeur : Le nom du paramètre passé par valeur

10
 Les fonctions 20

7) Modes de passage des paramètres

► Passage par valeur

▪ La déclaration d'un passage par valeur s'effectue de la manière suivante :

➢ Exemple 1: Le paramètre a est passé à la fonction CalculerTriple par valeur.

… …

void CalculerTriple (int a ){ int main(){

a=3*a; int a ;

} cin>> a ; // supposons que a = 3

…. CalculerTriple (a)
cout<< "le résultat est =" << a ; // Affiche 3 puisque la valeur de a n'a pas changé
return 0;
}

Les fonctions 21

7) Modes de passage des paramètres

► Passage par valeur

▪ La déclaration d'un passage par valeur s'effectue de la manière suivante :

➢ Exemple 2: Les deux paramètres a et b sont passées à la fonction Permutation par valeur.

Supposons que a = 1 et b = 2
… …
// Appel de la fonction Permutation
void Permutation (int a , int b){ int main(){
Résultat ?
int aux ; int a,b ;
aux = a ;
Affiche a=1 b=2 (Les valeurs n’ont pas changé)
cin>> a >> b ;
a=b ; Permutation (a, b); → La modification effectuée sur a et b à l'intérieur

b=aux ; cout<< "a=" << a << "b=" << b ; de la fonction Permutation n'est pas récupérée à
} return 0; l'extérieur de cette dernière.
…. Pourquoi ?
}

11
 Les fonctions 22

7) Modes de passage des paramètres

► Passage par valeur

▪ Réponse : Les valeurs des arguments au moment de l'appel (paramètres effectifs) sont recopiées dans les éléments de données locaux

correspondants à la fonction (paramètres formels).

… a 1 2 b …
void Permutation (int a , int b){ int main(){ Copier
int aux ; a b aux
aux = a ; 1 2 1 …
a=b; 2 2 1 Permutation (a, b); 1 2
b = aux ; 2 1 1 … a b
} }
….

Les fonctions 23

7) Modes de passage des paramètres

► Passage par adresse

▪ Dans un passage par adresse d'un argument on impose à la fonction de travailler non plus sur une copie locale du paramètre effectif, mais

plutôt directement sur ce dernier.

→ Pas de copie du paramètre effectif dans le paramètre formel, le travail se fait directement sur le paramètre effectif.

▪ De cette façon, toute modification effectuée à l'intérieur de la fonction sera en réalité réalisée sur le paramètre effectif.

→ Les modifications seront visibles à l'extérieur de la fonction.

▪ Ce mode de passage de paramètre est effectué en faisant passer à la fonction l'adresse du paramètre effectif.

→ Toute référence à ce dernier de l'intérieur de la fonction doit se faire à l'aide de l'opérateur d'indirection (*)

12
 Les fonctions 24

7) Modes de passage des paramètres

► Passage par adresse

▪ La déclaration d'un passage par adresse s'effectue de la manière suivante :

➢ Syntaxe de déclaration

TypeFonction NomFonction (……, Type* ParamAdresse,…); // ParamAdresse étant le paramètre passé par adresse et Type étant son type

➢ Syntaxe de la manipulation d'un paramètre passé par adresse à l'intérieur de la fonction

TypeFonction NomFonction (……, Type* ParamAdresse,…){

… *ParamAdresse ;

➢ Syntaxe de passage du paramètre par adresse au moment de l'appel de la fonction

NomFonction (……, &ParamAdresse,…);

Les fonctions 25

7) Modes de passage des paramètres

► Passage par adresse

➢ Exemple

… a 1 2 b …

void Permutation (int *a , int *b){ int main(){

int aux ; int a, b ;
cin>> a >> b ; Supposons que a = 1 et b = 2
aux = *a ;
Permutation (&a, &b); // Appel de la fonction Permutation Résultat ?
*a=*b ;
*b=aux ; cout<< "a=" << a << "b=" << b ; 1 2 Affiche a=2 | b=1

return 0; a b → Les valeurs ont changé

}
→ La fonction travaille
…. }
directement sur les
paramètres effectifs.

13
 Les fonctions 26

7) Modes de passage des paramètres

► Passage par référence (C++ seulement)

▪ Par rapport au C, le C++ introduit un nouveau mode de passage de paramètres appelé le passage par référence.

▪ Dans le passage par référence, toute modification effectuée sur le paramètre formel de la fonction est répercutée directement sur le

paramètre effectif.

▪ La déclaration d'un passage par référence s'effectue en adjoignant au type du paramètre à passer le symbole &.

Les fonctions 27

7) Modes de passage des paramètres

► Passage par référence (C++ seulement)

▪ La déclaration d'un passage par référence s'effectue de la manière suivante :

➢ Syntaxe de déclaration

TypeFonction NomFonction (…, Type& ParamRéf,…); // ParamRéf étant le paramètre passé par référence et Type étant son type

➢ Syntaxe de la manipulation d'un paramètre passé par référence à l'intérieur de la fonction

TypeFonction NomFonction (…, Type& ParamRéf,…){

… ParamRéf ;

➢ Syntaxe de passage du paramètre par référence au moment de l'appel de la fonction

NomFonction (…, ParamRéf,…);

14
 Les fonctions 28

7) Modes de passage des paramètres

► Passage par référence (C++ seulement)

➢ Exemple :

… …

void Permutation (int& a , int& b){ int main(){

Supposons que a = 1 et b = 2
int aux ; int x, y ;
Résultat ?
aux = a ; cin>> x >> y ;
Affiche a=2 | b=1
a=b ; Permutation (x, y); // Appel de la fonction Permutation
→ Les valeurs ont changé
b=aux ; cout<< "x=" << x << "y=" << y ;
→ La fonction travaille
} return 0;
directement sur les
…. } paramètres effectifs.

Les fonctions 29

8) Transmission des tableaux comme arguments d'une fonction

▪ Si un tableau figure comme argument d'une fonction alors son passage se fait toujours par adresse.

→ Le passage d'un tableau comme paramètre d'une fonction est impossible en tant que valeur.

→ La recopie du tableau prendrait trop de temps et de place.

→ On passe donc à la fonction l'adresse du tableau.

→ Cela permettra à la fonction d'effectuer des lectures et des écritures directement dans le tableau

→ Toutes les opérations et modifications appliquées à ses éléments seront visibles à l'extérieur de la fonction.

15
 Les fonctions 30

8) Transmission des tableaux comme arguments d'une fonction

▪ Exemples :

➢ Méthode 1 : Paramètre de type tableau avec dimension

// Par référence …
void Incrementation (int (&TabEnt) [5], int Taille){ int main(){
for (int i =0 ; i<Taille; i++) // Taille est une constante qui représente la taille du tableau = 5
TabEnt[i]++ ; const int Taille = 5 ;
} int TabEnt [Taille]= {0,1,2,3,4} ;
// Par adresse Incrementation (TabEnt, Taille); // Appel de la fonction Incrémentation
void Incrementation (int TabEnt[5], int Taille){ for (int i =0 ; i<Taille; i++)
for (int i =0 ; i<Taille; i++) cout << TabEnt[i] ; // Affiche 1 2 3 4 5
TabEnt[i]++ ;
} return 0;
}

Passage par adresse : le tableau est converti implicitement en pointeur vers son premier élément lors de l'appel .
Ceci serait donc équivalent : void Incrementation (int *TabEnt , int Taille)

Les fonctions 31

8) Transmission des tableaux comme arguments d'une fonction

▪ Exemples :

➢ Méthode 2 : Paramètre de type tableau sans dimension

// Par référence …
void Incrementation (int (&TabEnt)[], int Taille){ int main(){
for (int i =0 ; i<Taille; i++) const int Taille = 5 ; // Taille est une constante qui représente la taille du tableau = 5
TabEnt[i]++ ; int TabEnt [Taille]= {0,1,2,3,4} ;
} Incrementation (TabEnt, Taille); // Appel de la fonction Incrémentation
// Par adresse for (int i =0 ; i<Taille; i++)
void Incrementation (int TabEnt[], int Taille){ cout << TabEnt[i] ; // Affiche 1 2 3 4 5
for (int i =0 ; i<Taille; i++)
TabEnt[i]++ ; return 0;
} }

16
 Les fonctions 32

Exercice d’application

▪ Écrire un programme en langage C++ qui contient les fonctions suivantes:

1) Une fonction « Remplissage » pour remplir un tableau T par N entiers positifs entrés au clavier.

2) Une fonction « Affichage » pour afficher le tableau T.

3) Une fonction « Recherche » qui permet de rechercher et d'afficher les valeurs qui se trouvent dans une plage donnée dans un tableau

d'entiers et l'utilisateur devra spécifier une valeur minimale et maximale de la plage de recherche.

4) Une fonction principale « main » permettant d’utiliser ces fonctions.

Les fonctions 33

Exercice d’application

▪ Écrire un programme en langage C qui permet de :

1) Une fonction « Remplissage » pour remplir un tableau T par N entiers positifs entrés au clavier.

// Fonction pour remplir le tableau T int main(){

void Remplissage (int T[], int N) { int N;
int i ; // Demander à l'utilisateur la taille du tableau
cout <<"Entrez les éléments du tableau :"<<endl; cout << "Entrez le nombre d'éléments dans le tableau : ";
for (i=0 ; i<N;i++) { cin>>N;
do{ int T[N]; // Déclarer le tableau avec la taille spécifiée
cout<<"Donner T["<<i<<"] : " ; Remplissage(T, N);
cin>> T[i]; return 0;
}while (T[i]<0); }
}}

17
 Les fonctions 34

Exercice d’application

▪ Écrire un programme en langage C qui permet de :

2) Une fonction « Affichage » pour afficher le tableau T..

// Fonction pour afficher le tableau T int main(){

void Affichage (int T[], int N) { ….
int i ; Remplissage(T, N);
cout << "les éléments du tableau :" <<endl; Affichage(T, N);
for ( i = 0; i < N; i++) { return 0;
cout << " | "<< T[i] ; }
}
}

Les fonctions 35

Exercice d’application

▪ Écrire un programme en langage C qui permet de :

3) Une fonction « Recherche » qui permet de rechercher et d'afficher les valeurs qui se trouvent dans une plage donnée.

// Fonction pour afficher les valeurs dans la plage spécifiée int main(){
void Recherche (int T[], int N, int valeurMin, int valeurMax ) { ….
int i ; bool valeursTrouvees = false; int valeurMin, valeurMax ;
for (i = 0; i < N; i++) { // Demander à l'utilisateur la plage de recherche
if (T[i] >= valeurMin && T[i] <= valeurMax) { cout<<endl<<"Entrez la valeur minimale de la plage : ";
cout << T[i]<< " "; cin>>valeurMin;
valeursTrouvees = true; } cout<<endl<<"Entrez la valeur maximale de la plage : ";
} cin>>valeurMax;
// Si aucune valeur n'est trouvée dans la plage, afficher un message approprié Recherche (T, N, valeurMin, valeurMax ) ;
if (valeursTrouvees==false) { return 0;
cout << "Aucune valeur trouvée dans la plage spécifiée."; } }
}

18
 Les fonctions 36

9) Les fonctions en ligne

▪ Une fonction en ligne est une fonction expansée à chaque appel.

→ En d'autres mots, le corps de la fonction est inséré dans le module appelant à l'endroit de l'appel.

▪ À quoi ça sert ?

→ Les fonctions en ligne permettent d'accélérer l'exécution en évitant les allées-retours entre la fonction et le module appelant.

▪ La fonction inline est l’une des fonctionnalités importantes de C ++.

Remarques : → La déclaration et la définition d'une fonction en ligne doivent obligatoirement précéder son appel.

→ Les fonctions en ligne sont généralement de petite taille (1 à 3 instructions).

Les fonctions 37

9) Les fonctions en ligne

▪ La déclaration de ce type de fonction s'effectue de la manière suivante :

➢ Syntaxe :

inline TypeFonction NomFonction (Type_1 arg_1,…, Type_n arg_n);

➢ Exemples :

// Fonction qui renvoie la valeur absolue de la variable x // Fonction qui renvoie le maximum de deux variables x et y

inline int signe(int x){ inline int max(int x, int y){

return x>0 ? x : -x ; return x>y ? x : y ;

} }

… …

19
 Les fonctions 38

10) Surcharge de fonctions (surdéfinition)

▪ La surcharge de fonctions consiste à proposer plusieurs définitions d'une même fonction au sein d'un même programme.

→ Ces définitions doivent se distinguer par leurs signatures.

→ La signature d'une fonction est définie par le nombre, le type et l'ordre de ses paramètres.

→ La valeur de retour n'entre pas en considération dans ce cas

// Surcharge correcte ✓ // Surcharge incorrecte ×

int f (int , char) ; int f (int , char) ;
int f (char, int) ; char f (char, int) ;

▪ À quoi ça sert ?

→ On surcharge généralement les fonctions qui font le même traitement, mais sur des données de types différents.

Les fonctions 39

10) Surcharge de fonctions (surdéfinition)

▪ La déclaration de ce type de fonction s'effectue de la manière suivante :

➢ Syntaxe :

TypeFonction NomFonction (Type_1 arg_1,…, Type_n arg_n);

➢ Exemples :
// Fonction qui renvoie la position de la valeur maximale dans le // Fonction qui renvoie la position de la valeur maximale dans le
tableau d’entiers T tableau de réels T
int MaxTab(int T[], int n) { int MaxTab(double T[], int n) {
int i, pos, max=T[0] ; int i, pos ; double max=T[0] ;
for(i=0 ; i<n ; i++) { for(i=0 ; i<n ; i++) {
if(T[i]> max) { if(T[i]> max){
max = T[i]; pos = i; } max = T[i]; pos = i; }
} }
return pos; return pos;
} }

20
 Les fonctions 40

11) Arguments par défaut d'une fonction

▪ Des valeurs par défaut peuvent être affectées aux arguments d'une fonction.

▪ Ces arguments ont généralement des valeurs habituelles qu'il n'est pas nécessaire de spécifier à chaque utilisation.

▪ La déclaration s'effectue de la manière suivante :

TypeFonction NomFonction (Type_1 arg_1, Type_2 arg_2, , Type_3 arg_3 = Val);

➢ Exemple

int f (int a , int b=0) ; // déclaration d’une fonction f qui a comme paramètre a et b qui a une valeur par défaut 0

Remarque1 : Seuls les derniers arguments, de la droite vers la gauche peuvent avoir des valeurs par défaut

void g (int a = 3, int b, int c=5); // Erreur

void g (int a, int b=6, int c =8); // OK

Les fonctions 41

11) Arguments par défaut d'une fonction

▪ Remarque 2 :

→ Si la valeur d'un argument par défaut a été spécifiée dans la déclaration de la fonction, alors elle ne doit pas être mentionnée à

nouveau dans la définition.

→ Si une fonction est directement définie, alors la valeur par défaut doit être spécifiée dans la définition

➢ Exemple :

// Déclaration + définition // Définition directe int f (int a = 1) { return a*2 ;}

void f (int a = 0); void f (int a = 0) { // Ok int main(){

void f (int a = 0) { // Erreur … cout<<f(); // Affiche 2

… } return 0;

} }
Au moment de l'appel de la fonction, la spécification de
l'argument par défaut est optionnelle

21
Fin du cours

22