16/02/2021

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

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

MASTER 1: RT/II/ESE/IB 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
 16/02/2021

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
 16/02/2021

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
 16/02/2021

Fonctions sans valeur de retours

Fonctions sans arguments

prototypages

4
 16/02/2021

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
 16/02/2021

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
 16/02/2021

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
 16/02/2021

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
 16/02/2021

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
 16/02/2021

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
 16/02/2021

Les fonctions – paramètres par valeur

21

Fonctions – paramètres par valeur

22

11
 16/02/2021

Fonctions – paramètres par valeur

23

Fonctions – paramètres par valeur

24

12
 16/02/2021

Fonctions – paramètres par valeur

25

Fonctions – paramètres par valeur

26

13
 16/02/2021

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

27

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.

28

14
 16/02/2021

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;
}
29

Fonctions – paramètres par réf.

30

15
 16/02/2021

Fonctions – paramètres par réf.

31

Fonctions – paramètres par réf.

32

16
 16/02/2021

Fonctions – paramètres par réf.

33

Fonctions – paramètres par réf.

34

17
 16/02/2021

Fonctions – paramètres par réf.

35

Fonctions – paramètres par réf.

36

18
 16/02/2021

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!

37

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é.

38

19
 16/02/2021

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);

39

Fonctions – paramètres par prt

Dans le 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;

40

20
 16/02/2021

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;

41

Fonctions – paramètres par pointeur

42

21
 16/02/2021

valeur de retour

43

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;

44

22
 16/02/2021

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;
}

45

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);
}
46

23
 16/02/2021

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";
...
}

47

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>

48

24
 16/02/2021

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)»).
49

Arguments par défaut

50

25
 16/02/2021

inline

51

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

inline int pred ( int ch )

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

Ne peut être que pour des fonctions locales!

52

26
 16/02/2021

Fonctions – inline

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

code
celui-ci aura une taille plus importante.
importante

Le compilateur n’est pas obligé de tenir compte du

« inline » pour le code généré.

53

surcharge

54

27
 16/02/2021

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.
55

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

La surcharge n’existe pas en C

56

28
 16/02/2021

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;
}

57

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
58 GM Breguet – v1.5 / mars ‘09

29
 16/02/2021

Fonctions – surcharge

Derrière la simplicité apparente,

apparente les mécanismes qui
régissent la surcharge s’avèrent complexes et parfois
difficiles à appréhender.

Attention par exemple au fait qu’une déclaration

locale masque une déclaration globale de même
nom.

59

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.

60

30
 16/02/2021

Surcharge des fonctions

61

Surcharge des noms de fonctions

62

31
 16/02/2021

Surcharge des noms de fonctions

63

C++: Algorithme de résolution des surcharges

64

32
 16/02/2021

C++: Algorithme de résolution des surcharges

65

C++: Algorithme de résolution des surcharges

66

33
 16/02/2021

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
}
67

34