Les fonctions

◼ Définition d’une fonction

◼ Appel d’une fonction
◼ Déclaration d’une fonction (prototype)
◼ Mode de passage des paramètres
◼ Les fonctions inline
◼ La surcharge de fonction
 Les fonctions
◼ A quoi ça sert ?
◼ Décomposer un problème en sous problèmes.
◼ Simplification algorithmique pour le programmeur.

◼ Réutiliser des séquences d’instruction.

◼ Diminution de l’effort de programmation.

◼ Augmentent la lisibilité et la fiabilité du programme.

◼ Elle prend en entrée un liste d’argument et

retourne une valeur en sortie.
 Définition d’une fonction
◼ Elle comporte 4 parties:
Le nom de la fonction

Type Nom ( TypeArg NomArg, …., TypeArg NomArg)

{
instruction
…….
return VariableRetour;
}
Le type de la valeur
retournée par la fonction
La déclaration des arguments
(int, char, float…) ou void
Le corps de (type + nom)
la fonction
Avec l’instruction return
Entre accolades
 Définition d’une fonction
◼ Une fonction peut ne renvoyer aucune valeur
◼ Une fonction peut ne prendre aucuns paramètres.
int somme( int i , int j )
{
return i+j;
}

void rien ( ) /* Fonction n’attendant pas de paramètres */

/* on aurait pu ecrire void rien (void).*/
{ /* et ne renvoyant pas de valeur. */
return; /* Cette ligne est facultative. */
}

Pas obligatoire
 Appel d’une fonction
◼ Syntaxe:
NomFonction (Arguments)
long modulo (long a, long b) // modulo renvoie un long
{………….}

void traite (int x) // traite ne renvoie rien

{………….}

int main()
{
int x = 2; int i = 5; int y;

traite (x); //appel de traite comme fonction

y = modulo(i,7); //appel de modulo comme fonction
}
 Déclaration d’une fonction (prototype)
◼ Pour faire appel à une fonction, il faut que le compilateur soit averti de son
existence, de ses arguments, de sa valeur de retour.
◼ Soit on définit la fonction avant l’appel.
◼ Soit on déclare la fonction avant l’appel. (on peut dans ce cas la définir après.)
◼ Syntaxe:

Type Nom ( TypeArg NomArg, …., TypeArg NomArg ) ;

Point virgule à la fin ! Pas obligatoire

 Déclaration d’une fonction
(prototype)

Déclaration possible de f
Définition de f À éviter
double f (); Le nombre d’arguments
Double f ( char x) n’est pas précisé
{ double f ( char y );
int t;
….. double f ( char );
…..
}
 Exemple

int Min( int , int ); /* Déclaration de la fonction minimum */

/* définie plus loin. */
/* Fonction principale. */
void main()
{
int i = Min(2,3); /* Appel à la fonction Min, déjà déclarée. */

/* Définition de la fonction min. */

int Min( int i , int j)
{
if ( i < j ) return i;
else return j;
}
 Exemple : void

◼ Les deux cas d’utilisation

◼ Pas de valeur de retour

void f (char x, int y ) ; // f n’a pas de valeurs de retour

◼ Pas d’arguments

int g (void ) ; // g fonction sans arguments

int h (); // h fonction dont le nombre d’arguments

// n’est pas précisé dans la déclaration
 Mode de passage des paramètres

◼ Les paramètres d’entrée.

◼ Exemple : factorielle ( n )

◼ Les paramètres de sortie.

◼ Exemple : MinMax (entier1, entier2, min, max)

◼ Les paramètres d’entrées / sortie.

◼ Exemple : EchangerValeur(a,b)
 Mode de passage des paramètres

◼ Le passage par valeur:

◼ Lors de l’appel de la fonction, les arguments sont passés par valeur.
◼ La fonction appelée travaille sur des copies des arguments.
◼ Elle ne peut pas modifier les arguments passés en paramètres.

◼ Utile pour les paramètres d’entrée

 Exemples du passage par valeur
void calcul ( int entree)
{
Création d’une variable entrée
entree = 6;
On copie dans entrée la valeur de a
}

Puis on modifie la valeur de entrée

Par contre a reste inchangé
int main ()
A la sortie de la fonction,
{
la variable entrée est détruite
int a = 3;
calcul (a);
cout << a; // la valeur affiché sera 3

return 0;

}
 Mode de passage des paramètres

◼ Le passage par référence:

◼ Lors de l’appel de la fonction, les arguments sont passés par
référence.
◼ Un lien est créé entre les arguments passés en paramètre et les
variables correspondantes créées par la fonction.
◼ La fonction peut alors modifier les arguments passés en paramètres.
◼ Utile pour les paramètres de sortie et d’entrée / sortie
Exemples du passage par référence
void calcul ( int & entree)
{ Création d’une variable entrée.
entree = 6; On lie la variable entrée à
} la variable a

Puis on modifie la valeur de entrée

et donc de a
void main ()
{ A la sortie de la fonction,
int a = 3; la variable entrée est détruite.
calcul (a); a reste bien sûr intact
cout << a; // la valeur affiché sera 6 et sa valeur a changé

}
 Valeur par défaut
◼ Permet de donner une valeur par défaut au arguments.

void affiche(int x=1)

{
cout << x << endl;
}

void main()
{
int y=5 ;
int buf ;
affiche(y); //affiche 5
affiche(); //affiche 1

}
 Valeur par défaut
◼ Deux règles importantes:
◼ La valeur ne doit être précisé qu’une seule fois!

◼ Dans la définition s’il n’y a pas de déclaration.

◼ Dans la déclaration sinon.

void affiche(int x = 1) ;
void main()
{
◼ Si un argument en possède une, int y=5 ; alors tout
les arguments suivant int buf ;
◼ doivent en posséder une affiche(y); //affiche 5
affiche(); //affiche 1

// incorrect => erreur de compilation }

void fonction( int a, int b=0, int c)
void affiche(int x)
{
// correct cout << x << endl;
void fonction( int a, int b=0, int c=10) }
 Passage de tableaux en paramètre
◼ .
int main()
{ void Fonction( int x[ ] )
int tab[20]; { Ne pas préciser la
….. ….. taille du tableau
Fonction ( tab); …..
} Pas de passage par valeur
} ou référence
◼ Le tableau d’origine
peut être modifié
dans tout les cas!
int main()
{ void Fonction( int x[ ][4] )
int tab[10][4]; { Ne pas préciser
….. ….. la première taille
Fonction ( tab); …..
}
}
 Les fonctions inline
◼ Le langage C++ introduit le concept de
fonction en ajoutant le mot clé
. Ce mot clé permet de définir des
fonctions qui seront directement
évaluées à la compilation, et dont
l'appel dans le programme sera
remplacé par la valeur évaluée.
 Les fonctions inline
◼ Ce concept de pseudo-fonction était
déjà possible en langage C, grâce à la
directive de préprocesseur .
Toutefois cette directive ne permettait
aucun contrôle de type, ce que le mot
clé réalise...
 Exemple
inline int Double(int a);
void main()
{
int b = 3;
b = Double(b);
}
inline int Double(int a) { return 2*a; }

◼ Le mot clé inline est indispensable dans le prototype

◼ Le mot clé inline est facultatif à la définition
 La surcharge de fonction

◼ Un des apports les plus intéressants du C++

par rapport au C, hormis l'ajout du concept
objet, est la possibilité d'appeler plusieurs
fonctions avec le même nom, pour peu que
celle-ci aient leurs arguments différents (en
type et/ou en nombre).

◼ Ce principe est appelé surcharge de fonction. Il

permet de donner le même nom à des fonctions
comportant des paramètres différents et
simplifie donc l'écriture de fonctions
sémantiquement similaires sur des paramètres
de type différent.
 La surcharge de fonction

En effet, une fonction est déterminé par ce

que l'on appelle sa signature, c'est-à-dire:
•

•
La surcharge de fonction
 Pointeur et fonction

// passage par valeur // passage par référence // passage par pointeur

void Fonction1(int a) void Fonction2(int & a) void Fonction3(int * a)
{ { {
a = 2; a = 2; *a = 2;
return; return; return;
} } }

int x=0; int y=0; int z=0;

Fonction1(x); // la valeur de x ne change pas (passage par valeur)
Fonction2(y); // la valeur de y passe à 1 (passage par référence)
Fonction3(&z); // la valeur de z passe à 1 (passage par pointeur)
// on passe l’adresse de z à la, fonction 3 qui réclame un pointeur en paramètre
 Exemple
int LongueurChaine2( char *ch )
int LongueurChaine1( char ch[ ] ) {
{ int i = 0;
int i = 0; while ( ch[i] != ‘\0’)
while ( ch[i] != ‘\0’) i++;
i++; return i;
return i; }
}

Ou encore

int LongueurChaine3( char *ch )

{
int i = 0;
char tab[3]; while ( *ch != ‘\0’)
char * tabP=new char[3]; {
LongueurChaine1(tab); ch++;
LongueurChaine2(tab); i++;
LongueurChaine1(tabP); }
LongueurChaine2(tabP); return i;
}
 Pointeur et fonction
◼ Mettre un tableau en valeur de retour n’avait pas de sens car l’affectation n’était pas
possible ensuite.
◼ Mettre un pointeur en retour de fonction est possible.

char * CreateChaine (const int Size)

{ int main()
char * Chaine = new char [Size]; {
char * tabP;
for (int i=0;i<Size-1;i++) tabP = CreateChaine(10); // OK
Chaine [i] = 'A'; // il faudra désallouer tabP
//a la fin du programme
Chaine [Size-1] = '\0'; char tab[10];
tab = CreateChaine(10); /// ERREUR
return Chaine;
}
}