Vous êtes sur la page 1sur 28

25/11/2016

UNIVERSITÉ DES SCIENCES ET DE LA TECHNOLOGIE D’ORAN « USTOMB »


FACULTÉ DE GÉNIE ÉLECTRIQUE - DÉPARTEMENT D’ELN

MASTER 1: ESE/II/RT MODULE: POO

les fonctions en C++

La responsable du module: Dr. Zouagui-Meddeber L.


lmeduniv@gmail.com

Les fonctions

Une fonction permet de


instruction; Fonction()
regrouper une ou
...
plusieurs instructions Fonction();
sous un même nom. ...
instruction;
Une fonction peut être ...
appelé plusieurs fois à des Fonction();
...
endroits différents.

1
25/11/2016

Les fonctions
La structure d’une fonction est la suivante
type liste de
nom paramètre(s)
retourné
void maFonction () {
{ corps:
// déclaration(s) déclarations
... … et / ou …
instructions
// instruction(s) }
...
}

Les fonctions
Cette fonction ne retourne rien « void » et ne prend aucun
paramètre
#include <iostream>
#include <cstdlib>
using namespace std;

void presenterPgm ()
Dans d’autre langage, {
ce serait une procédure. cout << "ce pgm …";
}
int main ()
{
presenterPgm();
return EXIT_SUCCESS;
}
4

2
25/11/2016

Les fonctions – type « void »


Le mot réservé « void » indique l’absence de typage.

Dans le cadre des Fonctionss, il est utilisé pour spécifier qu’une


fonction

• ne retourne aucune valeur


et / ou
• ne prend aucun paramètre
en C++ des parenthèses vides signifient qu’il n’y a pas de
paramètres
5

Les fonctions – type « void »


#include <iostream>
using namespace std;
Affichage1
void b() Bonjour
{ cout<<"Bonjour"<<endl; } Affichage2
int main()
Bonjour
Bonjour
{ cout<<"Affichage1"<<endl; b();
Affichage3
cout<<"Affihage2"<<endl; b();
Bonjour
b(); cout<<"Affichage3"<<endl;
b();
return 0;
}

3
25/11/2016

Fonctions sans valeur de retours

Fonctions sans arguments

prototypages

4
25/11/2016

Prototypage
La mise en œuvre d’une fonction se fait en 2 étapes:
La syntaxe d’un prototypage est:

Où type est le type de la valeur de retour renvoyée par la fonction,


identificateur est le nom donné à la fonction, et arguments est la liste des
arguments formels, de la forme:
type1 id-arg1, type2 id-arg2, ..., typen id-argn
La définition d’une fonction permet «l’affectation» d’un corps (bloc
d’instructions) au prototype de la fonction.
La syntaxe d’une définition est:

Prototypage

10

5
25/11/2016

paramètres

11

Les fonctions – paramètres


S’il n’était pas possible de piloter les fonctions de l’extérieur,
leur utilité serait bien discutable.

void afficherSurface ()
{
// déclarations
int longueur = 12;
int largeur = 21;

// calcul de la surface
cout << "la surface = "
<< longueur * largeur;
}

Nous avons donc besoin de paramètre(s)


12

6
25/11/2016

Les fonctions – paramètres

En C++, on distingue pour les fonctions 2 types de


passage d’arguments:

le passage par valeur(copie): dans lequel la fonction


travaille sur des copies locales des arguments
transmis

et le passage par variable: dans lequel la fonction travaille


effectivement l’argument transmis lui-même.

13

Les fonctions – paramètres

Dans l’exemple précédent, l’appelant devrait pouvoir


transmettre la longueur et la largeur lors de l’appel.

void afficherSurface(int longueur, int largeur)


{
// calcul de la surface
cout << "la surface = "
<< longueur * largeur;
}

14

7
25/11/2016

Les fonctions – paramètres


On parle ici de paramètres d’entrées

En effet, les valeurs

• sont transmises par l’appelant


• ne sont utilisées qu’à l’intérieur de la fonction
• ne sont pas restituées à l’extérieur

15

Les fonctions – paramètres

afficherSurface(1,
1 22);

void afficherSurface (int longueur,


int largeur )
{
// calcul de la surface
cout << "la surface = "
<< longueur * largeur;
}

afficherSurface(2, 1); // => 2*1 = 2


afficherSurface(3, 2); // => 3*2 = 6
const int largeur = 4;
afficherSurface(largeur, 3); // => 4*3 = 12
16

8
25/11/2016

Fonctions – paramètres
Que valent les paramètres ?
const char CAR = 'A';
int nbre = 12;
void sp (int p1,
char p2 )
{
...
}

Appels à sp
sp(…)
(…) p1 p2
sp (1, 'a'); 1 car 'a'
sp (1, 65); 1 65 => 'A'
sp ('A', 67); 'A' => 65 67 => 'C'
sp (1, CAR); 1 A => 'A'
sp (nbre, CAR+1); nbre => 12 A+1 => 'B'
17

Fonctions – paramètres par valeur


Passage par copie
nbre CAR

12 'A'
const char CAR = 'A';
int nbre = 12;
void sp (int p1,
p1 p2
char p2 )
{ 12
1 'A'
'd'
...
}
sp (1, 'd');
...
sp (nbre, CAR);

18

9
25/11/2016

Les fonctions – paramètres par valeur

La fonction dispose de ses propres copies sans pour autant les


retourner à l’appelant.

Il peut donc les modifier localement sans aucune


conséquence pour l’extérieur.

19

Les fonctions – paramètres par valeur

void sp (int );
void sp (int nbre)
{
cout << "----------\n";
cout << "nbre=" << nbre;
cout << endl;
nbre = nbre + 2; nbre=3
cout << "nbre=" << nbre; ----------
cout << "----------\n"; nbre=3
} nbre=5
Void main() ----------
{int nbre = 3; nbre=3
cout << "nbre=" << nbre;
cout << endl;
sp (nbre);
cout << "nbre=" << nbre;}
20

10
25/11/2016

Les fonctions – paramètres par valeur

21

Les fonctions – paramètres variables

Il existe 2 possibilités pour transmettre des paramètres par


variables
• Les références n’existe pas en C
• Les pointeurs

22

11
25/11/2016

Les fonctions – paramètres par référence


Le plus simple est d’utiliser le mécanisme de référence « & »

• Ajouter l’opérateur & devant le paramètre formel


• Utiliser normalement le paramètre dans le Fonctions.

Il y a un accès direct au paramètre effectif


tout changement fait dans la fonction sera effectif pour
l’appelant.

23

Fonctions – paramètres par réf.


void sp (int &val)
{
cout << "----------\n";
cout << "val=" << val;
cout << endl;
val = val + 2;
cout << "val=" << val; nbre=3
cout << "----------\n"; ----------
} val=3
Void main() val=5
{int nbre = 3; ----------
cout << "nbre=" << nbre;
cout << endl;
nbre=5
sp (nbre);
cout << "nbre=" << nbre;
}
24

12
25/11/2016

Fonctions – paramètres par réf.

25

Fonctions – paramètres par pointeur


L’idée du « pointeur » est en somme très simple.

Au lieu de passer l’objet par copie(valeur), c’est son adresse


mémoire qui est passée.

Par un mécanisme d'indirection nous pourrons modifier


l'objet désigné par cette adresse!

26

13
25/11/2016

Fonctions – paramètres par pointeur

void sp (int *nbre)…

Indique au compilateur que ce n’est pas la valeur qui est


transmise, mais une adresse (un pointeur).

De plus, le type indique la nature de l’objet désigné.

27

Fonctions – paramètres par pointeur


A l’appel, il faut encore préciser que ce n’est pas la valeur qui est
passée, mais bien l’adresse du paramètre effectif.

Il faut alors utiliser l’opérateur d’adresse « & »

int nbre = 3;
sp (&nbre);

28

14
25/11/2016

Fonctions – paramètres par prt


Dans les Fonctions, il faut encore indiquer les indirections pour
ne pas faire des opérations sur les adresses mais bien sur ce
qui se trouve à l’adresse reçue.

*nbre = *nbre + 2;

29

Fonctions – paramètres par prt


void sp (int *val)
{
cout << "----------\n";
cout << "val=" << *val;
cout << endl;
*val = *val + 2;
cout << "val=" << *val; nbre=3
cout << "----------\n"; ----------
} val=3
val=5
int nbre = 3;
cout << "nbre=" << nbre; ----------
cout << endl; nbre=5
sp (&nbre);
cout << "nbre=" << nbre;

30

15
25/11/2016

Fonctions – paramètres par pointeur

31

valeur de retour

32

16
25/11/2016

Fonctions – valeur de retour

Au sens de certains languages, une fonction retourne un


résultat.

Cette fonctionnalité est assurée par le mot réservé


return.
return
return EXPRESSION;

33

Fonctions – valeur de retour


En pratique, un « return » interrompt l’exécution
de la fonction et
peut délivrer un résultat à l’appelant.
l’appelant

int plusUn (int valeur)


{
return valeur + 1;
}

34

17
25/11/2016

Fonctions – valeur de retour


Le type du résultat de l’expression est éventuellement
converti dans le type annoncé comme résultat de la fonction.

Conversion implicite
bool estImpair (int valeur)
{
return valeur % 2;
} Conversion explicite
bool estImpair (int valeur)
{
return bool(valeur % 2);
}
35

Fonctions – valeur de retour


Naturellement, les instructions placées
après un return ne seront jamais exécutées.

int plusUn (int valeur)


{
return valeur + 1;
...
cout << "inutile";
...
}

36

18
25/11/2016

Arguments par défaut

Lors de sa définition, une fonction peut être munie d’arguments avec


valeur par défaut, pour lesquels il n’est alors pas obligatoire de fournir
de valeur lors de l’appel de la fonction.
La syntaxe pour définir des arguments avec valeur par défaut est:
<type> <argument> = <valeur>

37

Arguments par défaut

Dans le cas du premier appel («afficherLigne(’*’)»), la valeur du second


argument n’étant pas spécifiée, celui-ci prend la valeur par défaut «5».
Par contre, il prend la valeur explicitement spécifiée («8») dans le cas du
second appel («afficherLigne(’+’,8)»).
38

19
25/11/2016

Arguments par défaut

39

inline

40

20
25/11/2016

Fonctions – inline
Pour rendre un code plus rapide, il est possible de proposer au
compilateur de remplacer les appels de Fonctions par les
instructions effectives.

inline int pred ( int ch )


{
return ch - 1;
} /* pred */

Ne peut être que pour des fonctions locales!


41

Fonctions – inline
Vous voyez que le mot-clé inline est ajouté au début du prototype ET
au début de la définition de la fonction. Cela signifie pour le
compilateur "A chaque fois qu'on fera appel à la fonction carre, on placera
directement le code de cette fonction à l'endroit de l'appel".
inline int carre(int nombre);
int main()
{ cout << carre(10) << endl; int main()
return 0; {
cout << 10 * 10 << endl;
} return 0;
inline int carre(int nombre) }
{ return nombre * nombre; }

Les fonctions inline étant recopiées dans le code,


code
celui-ci aura une taille plus importante.
importante

21
25/11/2016

surcharge

43

Fonctions – surcharge
Plusieurs fonctions peuvent porter le même nom si
leurs signatures diffèrent.
diffèrent

La signature d'une fonction correspond aux


caractéristiques de ses paramètres
• leur nombre
• le type respectif de chacun d'eux

Le compilateur choisira la fonction à utiliser selon les


paramètres effectifs par rapport aux paramètres formels
des fonctions candidates.
44

22
25/11/2016

Fonctions – surcharge
Les éléments suivants ne permettent pas de
différencier 2 surcharges

• résultat retourné par la fonction


• les valeurs par défaut des paramètres

45

Fonctions – surcharge

int plus (int gauche, double droite)


{
return gauche + (int)droite;
}
int plus (double gauche, int droite)
{
return (int)gauche + droite;
}
double plus (double gauche, int droite)
{
return gauche + (double)droite;
}

La surcharge n’existe pas en C


46

23
25/11/2016

Fonctions – surcharge
// no 1
int plus (int gauche, double droite)
{
return gauche + (int)droite;
}
// no 2
int plus (double gauche, int droite)
{
return (int)gauche + droite;
}

int monEntier = 3;
double monDouble = 3.14;

cout << plus (3, 3.14); // no 1


cout << plus(monEntier, monDouble ); // no 1
cout << plus(monDouble, monEntier); // no 2
47 GM Breguet – v1.5 / mars ‘09

Fonctions – surcharge
#include <iostream>
using namespace std;

int somme(int nb1, int nb2);


double somme(double nb1, double nb2);

void main()
{
cout << somme(10, 15) << endl << somme(2.5, 0.3) << endl;
}
int somme(int nb1, int nb2)
{
return nb1 + nb2;
}
double somme(double nb1, double nb2)
{
return nb1 + nb2;
}

24
25/11/2016

Fonctions – surcharge

Le compilateur choisit toujours la meilleure fonction


possible selon les règles suivantes

• Une fonction correspond exactement à la signature de l'appel


• Une conversion simple est possible:
possible tableau ou fonction transformé
en pointeur ou inversement; une variable transformée en constante (pas
l'inverse!)
• Une promotion automatique est possible
short ou char vers int; float vers double
• Une conversion du genre int vers float est possible.

Surcharge des fonctions

50

25
25/11/2016

Surcharge des noms de fonctions

51

Surcharge des noms de fonctions

52

26
25/11/2016

C++: Algorithme de résolution des surcharges

53

C++: Algorithme de résolution des surcharges

54

27
25/11/2016

MANIPULATIONS:
7. Ecrire un programme c++qui calcule le périmètre, la section ainsi que
le volume d’une sphère de rayon R en utilisant des fonctions.

# include < iostream>


Const pi= 3.141596;
float R,S,P,V;
void main ( )
{
lect_R ( ) ; // fonction qui lit le rayon R
S = cal_section ( ) ; // fonction qui calcule la section
P = cal_perimetre ( ) ; // fonction qui calcule le périmètre
V = cal_volume ( ) ; // fonction qui calcule le volume
affiche_ S_P_V (S, P, V) ; // fonction qui affiche les résultats S,P
etV
}
55

28

Vous aimerez peut-être aussi