Partie 9: Fonctions Membres — Programmation orientée objet en C++

Programmation Orientée Objet en C++
9ème Partie: Fonctions Membres

Fabio Hernandez
Fabio.Hernandez@in2p3.fr

Vue d'Ensemble
Notions de base
Types, variables, opérateurs
Contrôle d'exécution
Fonctions
Mémoire dynamique
Qualité du logiciel
Evolution du modèle objet
Objets et classes
Fonctions membres
Classes génériques
Héritage
Polymorphisme
Héritage multiple
Entrée/sortie

POO en C++: Fonctions Membres 257 © 1997-2003 Fabio HERNANDEZ

Table des Matières

Fonctions membres inline
Arguments par défaut
Le pointeur this
Surcharge des opérateurs
Fonctions amies
Données membres statiques
Fonctions membres statiques
Résumé



On peut classer les fonctions membres par rapport à leur
mission vis-à-vis de la classe
gestion (construction, destruction, copie, ...)
modification de l'état
consultation de l'état (attributs) de l'objet
fonctions d'aide
itération, pour les classes d'objets qui sont des conteneurs d'autres
objets
opérateurs (affectation, comparaison, ...)
L ’objectif de quelques-unes d ’entre elles est de permettre la
consultation des attributs, tout en gardant l ’encapsulation
le corps de la fonction membre est petit



C++ fournit un mécanisme pour que l ’exécution de ces fonctions
membres ne soit pas pénalisante en termes de performance
Le mot clé inline suggère au compilateur de remplacer l ’appel
par le corps même de la fonction
Exemple
la classe Point définie précédemment fournit deux fonctions membres
pour accéder aux attributs (coordonnées cartésiennes) d ’un objet de la
classe
ce sont des candidates à être des fonctions inline


Fonctions membres inline (suite)
class Point {
public:
// Constructors
...
// Modifiers
...

// Selectors
float getX() const;
float getY() const;
...
private:
// Data members
float x_;
float y_;
};



Nous avions défini les fonctions membres x() et y() dans le
fichier Point.cpp comme suit
float Point::getX() const
{
return x_;
}

float Point::getY() const
{
return y_;
}
Pour que le compilateur puisse optimiser l ’appel à ces fonctions
membres nous devons
ajouter le mot clé inline à la définition de la fonction
mettre l'implémentation de la fonction dans le fichier Point.h



En plus de l ’interface de la classe, le fichier Point.h
contiendra la définition de toutes les fonctions membres de
type inline

inline float Point::getX() const Le mot clé inline
{ est rajouté à la
return x_; définition de la
} fonction membre
inline float Point::getY() const
{
return y_;
}



Lors de l ’utilisation d ’une de ces fonctions membres
Point p(18.0, 70.0);
float offset = p.getX();
le compilateur "remplace" l ’appel à la fonction membre
Point::x() par le corps de la fonction, comme si nous avions
écrit
float offset = p.x_;
Avantages
amélioration des performances
préservation de l ’encapsulation
Inconvénients
le fichier .h de la classe peut devenir gros, ce qui ralentit la compilation
peut poser des problèmes à certains déboguers



Autre façon consiste à définir le corps de la fonction membre
dans la déclaration de l ’interface de la classe
class Point {
public:
...

// Selectors
float getX() const {return x_;}; // Not recommended
float getY() const {return y_;};
...
private:
...
};
Gros inconvénient: pollution de l ’interface


Contrôle d'Avancement

Le pointeur this
Fonctions amies
Résumé



C++ permet de définir la valeur par défaut des arguments des
fonctions (membres et non membres)
Si l ’on appelle la fonction sans ou avec une liste partielle
d ’arguments, le compilateur rajoutera les arguments qui
manquent avec les valeurs qui ont été spécifiées par défaut
Exemple: on modifie l ’interface de la classe Point comme
class Point {
public:
...
// Modifiers
void translate(float horizontal = 1.0, Arguments
float vertical = 1.0); par défaut
...
};


Arguments par défaut (suite)

Nous pouvons maintenant utiliser cette fonction membre comme
Point p(10.8, 30.4);
p.translate(); // p.translate(1.0, 1.0);
p.translate(5.0); // p.translate(5.0, 1.0);
p.translate(6.9, 7.0);
La possibilité de spécifier des arguments par défaut est utile
pour fournir une façon abrégée d ’utiliser une fonction membre
avec les arguments les plus souvent utilisés
attributs de création d’une fenêtre
chaîne nulle
valeurs booléens
…



Inconvénient: le texte du programme peut devenir confus
il est plus claire si on lit
p.translate(1.0, 1.0);
que
p.translate();
même si le résultat en exécution est identique



Les constructeurs peuvent aussi avoir des arguments par défaut
class Point {
public:
// Constructors/Destructor
Point(float initialX = 0.0 , float initialY = 0.0 );
Point(const Point& aPoint);
~Point();
...
};



Ceci offre la possibilité de construire un objet de cette classe
de plusieurs façons différentes, toutes faisant appel au même
constructeur
Point origin; // Point::Point(0.0, 0.0)
Point unit(1.0); // Point::Point(1.0, 0.0)
Point start(15.9, 45.3);
Notez que l ’implémentation de la classe (fichier .cpp) n ’est
pas modifiée: uniquement son interface (fichier .h)



Le pointeur this
Fonctions amies
Résumé


Le pointeur this

Dans certains cas, il est nécessaire dans le corps d'une fonction
membre de faire référence explicite à l'objet sur lequel la
fonction membre s'applique
Toutes les fonctions membres en C++ ont accès à un pointeur à
l'objet via le mot clé this
Exemple: on peut écrire la fonction membre translate de la
classe Point comme
void Point::translate(float horizontal, float vertical)
{
this->x_ += horizontal;
this->y_ += vertical;
};


Le pointeur this (suite)

this est un pointeur à un objet de la classe Point qui ne peut
pas être modifié
void Point::translate(float horizontal, float vertical)
{
this = 0; // COMPILATION ERROR: "this" is constant
}
Ceci est vrai pour n'importe quelle classe
this existe uniquement dans le contexte d'une fonction
membre
A quoi sert-il? Un exemple de son utilité dans le chapitre
suivant



Le pointeur this
Fonctions amies
Résumé



Avec les outils du langage étudiés jusqu'à présent nous pouvons
définir des nouvelles classes, créer des objets de ces classes et
les manipuler presque comme les objets des types primitifs
Néanmoins, avec des objets des types primitifs
int count;
int threshold;
nous pouvons écrire
if (count == threshold) {
...
}
if (count < 10000) {
...
}


Surcharge des opérateurs (suite)

Autrement dit, on peut utiliser les opérateurs arithmétiques et
logiques qui sont prédéfinis par le langage
C++ offre au programmeur la possibilité de définir la plupart
d'opérateurs pour une classe quelconque
Exemple: pour comparer deux objets de la classe Point nous
avons défini la fonction membre

bool Point::isEqualTo(const Point& aPoint) const
{
return (x_ == aPoint.x_) && (y_ == aPoint.y_);
}



Ceci nous permet de comparer deux objets de la classe Point
comme
Point origin;
Point target(15.0, 18.0);
...
if ( target.isEqualTo(origin) ) {
// do something when they are equal
}
Il est souhaitable de pouvoir comparer ces deux objets de la
même façon que l'on compare deux objets d'un type primitif
if (target == origin) {
}



Nous allons donc redéfinir l'opérateur d'égalité "==" pour les
objets de la classe Point
Tout d'abord, il faut modifier l'interface de la classe
class Point {
public:
...

// Operators
bool operator==(const Point& aPoint) const;
...
private:
...
};



Ensuite, il faut écrire l'implémentation de cette nouvelle
fonction membre
bool Point::operator==(const Point& aPoint) const
{
return (x_ == aPoint.x_) && (y_ == aPoint.y_);
}
Nous pouvons maintenant utiliser cet opérateur
Point origin;
...
if (target == origin) {
}



Ceci est équivalent à
if ( target.operator==(origin) ) {
}
l'opérateur de comparaison s'applique à l'objet target avec comme
argument l'objet origin
Notez la différence avec
if (origin == target) {
...
}
qui est équivalent à
if ( origin.operator==(target) ) {
...
}


Surcharge de l'opérateur d'inégalité
class Point {
public:
...

// Operators
bool operator!=(const Point& aPoint) const;
...
private:
...
};



Pour l'implémentation on peut utiliser l'opérateur de
comparaison déjà défini

inline bool Point::operator!=(const Point& aPoint) const
{
return (*this == aPoint) ? false : true;
}
Il est désormais possible d'écrire
Point origin;
...
if (target != origin) {
// do something when they are different
}



Limitations
uniquement un ensemble prédéfini d'opérateurs peuvent être surchargés
impossible d'introduire de nouveaux opérateurs (** par exemple)
la signification prédéfinie des opérateurs des types primitifs ne peut pas
être modifiée
la précédence des opérations n'est pas modifiée, indépendamment du
type (classe) des opérandes
Avantages
traitement uniforme des objets appartenant aux classes définies par le
programmeur et des objets des types primitifs
lisibilité du code
Inconvénient
peut se prêter à confusion si utilisé sans discrimination



Quels sont les opérateurs qui peuvent être surchargés?
+ ! << %= ->
- , >> ^= ->*
* = == &= new
/ < != |= delete
% > && *=
^ <= || <<
& >= += >>
| ++ -= []
~ -- /= ()



Surcharge de l'opérateur d'affectation
class Point {
public:
...

// Operators
bool operator!=(const Point& aPoint) const;
Point& operator=(const Point& aPoint);
...
private:
...
};



Surcharge de l'opérateur d'affectation (suite)

Point& Point::operator=(const Point& aPoint)
{
if (this == &aPoint)
return *this;
Affectation de
x_ = aPoint.x_;
tous les attributs à
y_ = aPoint.y_; partir de
return *this; l'argument
}



Si l'on veut affecter un objet de la classe Point on peut
désormais écrire
Point origin;
...
target = origin; // target.operator=(origin);
Surcharge de l'opérateur de sortie
avec des variables des types primitifs nous pouvons écrire
int count = 150;
...
cout << "count = " << count << endl;
nous voulons pouvoir faire pareil pour les objets de la classe Point
cout << "target = " << target << endl;



Surcharge de l'opérateur de sortie (suite)
et que sur l'écran apparaîsse
target = [13.0, 15.0]
Ceci est possible si l'on surcharge l'opérateur de sortie <<
Cet opérateur ne peut pas être une fonction membre de la
classe Point
il a besoin d'un objet de la classe ostream (dans l'exemple cout)
comme premier argument
équivalent à
cout.operator<<(target)
toute fonction membre de la classe Point est appliqué sur un objet de
cette classe



On peut donc définir cet opérateur comme une fonction non-
membre associée à la classe Point et implémentée dans le
fichier Point.cpp
#include <iostream>

ostream& operator<<(ostream& stream,
const Point& aPoint)
{
stream << '[‘
<< aPoint.getX()
<< ','
<< aPoint.getY()
<< ']';
return stream;
}


Le fichier Point.h contiendra, en plus de l'interface de la
classe, la déclaration du prototype de la fonction non-membre
#include <iostream>

class Point {
public:
...

private:
...
};
extern ostream& operator<<(ostream& stream,
const Point& aPoint);



Le pointeur this
Fonctions amies
Résumé


Fonctions amies

La fonction non-membre opérateur << a besoin des valeurs des
coordonnées x et y d'un objet Point
Elle utilise les fonctions membres fournies par la classe pour
accéder aux attributs de l'objet (Point::getX() et
Point::getY())
Si l'opérateur avait accès directe aux attributs x_ et y_ de
l'objet il n'aurait pas besoin d'appeler les fonctions membres
Mais les attributs sont privés, donc inaccessibles pour une
fonction non-membre de la classe
En C++ on peut définir des fonctions (ou des classes) amies
d'une classe


Fonctions amies (suite)

Une fonction (ou objet d'une classe) amie a accès à tous les
attributs de l'objet, indépendamment du contrôle d'accès
défini par la classe
Les fonctions (ou classes) amies sont déclarées comme telles
dans l'interface de la classe


#include <iostream>

class Point {
public:
...

// Operators
friend ostream& operator<<(ostream& stream,
const Point& aPoint);

// Modifiers
...
// Selectors
...

private:
...
};



On peut donc reécrire l'opérateur de sortie dans le fichier
Point.cpp
#include "Point.h"

ostream& operator<<(ostream& stream,
const Point& aPoint)
{
stream << '[‘
<< aPoint.x_
<< ','
<< aPoint.y_
<< ']';
return stream;
}



Avantages
moyen de contourner les mécanismes de contrôle d'accès
utile dans les cas où il est nécessaire, pour des raisons de performance
d'accéder, aux attributs privés d'un objet sans danger
Inconvénients
moyen de contourner les mécanismes de contrôle d'accès
fort couplage entre les classes (fonctions) amies
modifications peuvent être difficiles



Le pointeur this
Fonctions amies
Résumé



Il est parfois nécessaire de partager une même valeur par tous
les objets d'une classe
une condition
un compteur associé à la classe qui est modifié au fur et à mesure que
l'exécution du programme se poursuit
une valeur constante
Il est plus efficace d'avoir une seule variable ou constante pour
tous les objets de la classe au lieu d'une par chaque instance
(objet)
Une donnée membre statique peut être vue comme une variable
globale à la classe à laquelle elle appartient


Données membres statiques (suite)

Exemple: supposons qu'il est nécessaire de connaître le nombre
d'objets de la classe Point actifs à un moment donné
nous avons besoin d'un compteur au niveau de la classe Point
ceci est modélisé comme une donnée membre statique

class Point {
public:
...
private:
float x_;
float y_;
static int instanceCounter_;
};



L'implémentation des constructeurs et du destructeur sont
modifiées
Point::Point()
{
x_ = 0.0;
y_ = 0.0;
++instanceCounter_;
}

// similarly for the other constructors

Point::~Point()
{
--instanceCounter_;
}



Il est nécessaire aussi de donner une valeur initiale à cette
donnée membre
dans le fichier Point.cpp

int Point::instanceCounter_ = 0;

On pourrait ajouter une fonction membre pour accéder au
compteur d'instances

inline int Point::numberOfInstances() const
{
return instanceCounter_;
}



Notez que l'accès à une donnée membre statique est le même
que pour les autres attributs de l'objet
Les mécanismes de contrôle d'accès sont aussi respectés
Quel est le résultat de l'exécution du code ci-dessous?
Point p(15.0, 45.0);
cout << "Number of instances: "
<< p.numberOfInstances()
<< endl;
Point q;
<< q.numberOfInstances()
<< endl;



Une autre utilisation des données membres statiques est la
définition de constantes
Nous pourrions définir un ensemble de constantes physiques
et/ou mathématiques dans une classe
class PhysicalConstants {
public:
static const double LightSpeed;
static const double Gravitational;
static const double Boltzmann;
...
};



Définition de constantes à l'intérieur d'une classe (suite)

class MathConstants {
public:
static const double Pi;
...
};



Il faut leur donner les valeurs initiales correspondantes (fichier
PhysicalConstants.cpp et MathConstants.cpp)

const double PhysicalConstants::LightSpeed=3.00e8;
const double PhysicalConstants::Gravitational=6.67e-11;
const double PhysicalConstants::Boltzmann=1.38e-23;

const double MathConstants::Pi=3.1415926535;



Et pour utiliser ces constantes
#include "MathConstants.h"
float Point::theta()
{
if (x_ == 0.0) { // WARNING: not very safe
if (y_ == 0.0)
return 0.0;

const float Pi = MathConstants::Pi;
return (y_ > 0.0) ? 0.5*Pi : 1.5*Pi;
}

return atan(y_/x_);
}



Le pointeur this
Fonctions amies
Résumé


Fonctions membres statiques (suite)

Intuitivement, la fonction membre pour obtenir le nombre
d'instances de la classe Point devrait être attachée à la
classe elle même et non à une instance particulière
De la même façon que l'on définit des données membres
(constantes ou pas), on peut définir des fonctions membres
statiques
Une fonction de ce type est associée à la classe et non pas à
une instance
pas de référence implicite ou explicite au pointeur this
l'appel à une de ces fonctions suppose une syntaxe particulière



class Point {
public:
//Constructors/Destructor
...

// Selectors
static int numberOfInstances();
...

// Modifiers
...

private:
float x_;
float y_;
static int instanceCounter_;
};



La définition de la fonction est identique que dans le cas non
statique sauf pour le const

inline int Point::numberOfInstances()
{
return instanceCounter_;
}
L'utilisation varie
Point p(15.0, 45.0);
<< Point::numberOfInstances()
<< endl;


Résumé

Les fonctions inline permettent de remplacer les appels aux
fonctions membres tout en conservant l'encapsulation
On peut spécifier des arguments par défaut pour des fonctions
(membres et non-membres)
Les fonctions membres d'une classe ont accès à l'objet sur
lequel elles s'appliquent via le pointeur this
Les opérateurs arithmétiques et logiques peuvent être
redéfinis pour chaque classe créée par le programmeur
Les fonctions et classes amies offrent un moyen de contourner
le contrôle d'accès
Des données et fonctions globales à une classe peuvent être
définies


Partie 9: Fonctions Membres — Programmation orientée objet en C++

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (11)

Similaire à Partie 9: Fonctions Membres — Programmation orientée objet en C++

Similaire à Partie 9: Fonctions Membres — Programmation orientée objet en C++ (20)

Partie 9: Fonctions Membres — Programmation orientée objet en C++