partie 9: fonctions membres — programmation orientée objet en c++

Fabio [email protected]

Programmation Orientée Objet en C++Programmation Orientée Objet en C++

9ème Partie: Fonctions Membres9ème Partie: Fonctions Membres

© 1997-2003 Fabio HERNANDEZ257POO en C++: Fonctions Membres

Vue d'EnsembleVue d'Ensemble

Notions de base Types, variables, opérateursContrôle d'exécutionFonctionsMémoire dynamiqueQualité du logicielEvolution du modèle objet Objets et classesFonctions membresClasses génériquesHéritagePolymorphismeHéritage multipleEntrée/sortie


Table des MatièresTable des Matières

Fonctions membres inlineArguments par défautLe pointeur thisSurcharge des opérateursFonctions amiesDonnées membres statiquesFonctions membres statiquesRésumé


Fonctions membresFonctions membres inlineinline

On peut classer les fonctions membres par rapport à leur mission vis-à-vis de la classe

gestion (construction, destruction, copie, ...)modification de l'étatconsultation de l'état (attributs) de l'objetfonctions d'aideitération, pour les classes d'objets qui sont des conteneurs d'autres objetsopé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


Fonctions membresFonctions membres inlineinline

C++ fournit un mécanisme pour que l ’exécution de ces fonctions membres ne soit pas pénalisante en termes de performanceLe mot clé inline suggère au compilateur de remplacer l ’appel par le corps même de la fonctionExemple

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 classece sont des candidates à être des fonctions inline


Fonctions membresFonctions membres inlineinline (suite)(suite)

class Point {public:

// Constructors...// Modifiers...

// Selectorsfloat getX() const;float getY() const;...

private:// Data membersfloat 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 fonctionmettre l'implémentation de la fonction dans le fichier Point.h


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

inline float Point::getX() const{

return x_;}

inline float Point::getY() const{

return y_;}


Le mot clé inlineest rajouté à la définition de la

fonction membre



Lors de l ’utilisation d ’une de ces fonctions membresPoint 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_;

Avantagesamélioration des performancespréservation de l ’encapsulation

Inconvénientsle fichier .h de la classe peut devenir gros, ce qui ralentit la compilationpeut 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


...

// Selectorsfloat getX() const {return x_;}; // Not recommendedfloat getY() const {return y_;};...

private:...

};

Gros inconvénient: pollution de l ’interface


Contrôle d'AvancementContrôle d'Avancement

Fonctions membres inlineArguments par défaut Le pointeur thisSurcharge des opérateursFonctions amiesDonnées membres statiquesFonctions membres statiquesRésumé


Arguments par défautArguments par défaut

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éfautExemple: on modifie l ’interface de la classe Point comme


...// Modifiersvoid translate(float horizontal = 1.0,

float vertical = 1.0);...

};

Arguments par défaut


Arguments par défaut (suite)Arguments par défaut (suite)

Nous pouvons maintenant utiliser cette fonction membre commePoint 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êtrechaîne nullevaleurs booléens…



Inconvénient: le texte du programme peut devenir confusil est plus claire si on lit

p.translate(1.0, 1.0);

quep.translate();

même si le résultat en exécution est identique



Les constructeurs peuvent aussi avoir des arguments par défautclass Point {public:

// Constructors/DestructorPoint(float initialX = 0.0 , float initialY = 0.0 );Point(const Point& aPoint);~Point();...

};



Ceci offre la possibilité de construire un objet de cette classede 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)



Fonctions membres inlineArguments par défautLe pointeur thisSurcharge des opérateursFonctions amies Données membres statiquesFonctions membres statiquesRésumé


Le pointeurLe pointeur thisthis

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'appliqueToutes 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 pointeurLe pointeur thisthis (suite)(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 classethis existe uniquement dans le contexte d'une fonction membreA quoi sert-il? Un exemple de son utilité dans le chapitre suivant


Surcharge des opérateursSurcharge des opérateurs

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 primitifsNéanmoins, avec des objets des types primitifs

int count;

int threshold;

nous pouvons écrireif (count == threshold) {

...}if (count < 10000) {

...}


Surcharge des opérateurs (suite)Surcharge des opérateurs (suite)

Autrement dit, on peut utiliser les opérateurs arithmétiques et logiques qui sont prédéfinis par le langageC++ offre au programmeur la possibilité de définir la plupart d'opérateurs pour une classe quelconqueExemple: 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 Pointcomme

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 PointTout d'abord, il faut modifier l'interface de la classe


// Constructors/Destructor

...

// 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érateurPoint 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 avecif (origin == target) {

...}

qui est équivalent àif ( origin.operator==(target) ) {

...}



Surcharge de l'opérateur d'inégalité



...

// 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'écrirePoint origin;Point target(15.0, 18.0);...if (target != origin) {

// do something when they are different}



Limitationsuniquement un ensemble prédéfini d'opérateurs peuvent être surchargésimpossible d'introduire de nouveaux opérateurs (** par exemple)la signification prédéfinie des opérateurs des types primitifs ne peut pas être modifiéela précédence des opérations n'est pas modifiée, indépendamment du type (classe) des opérandes

Avantagestraitement uniforme des objets appartenant aux classes définies par le programmeur et des objets des types primitifslisibilité du code

Inconvénientpeut 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'affectationclass 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;

x_ = aPoint.x_;

y_ = aPoint.y_;

return *this;

}

Affectation de tous les attributs à

partir de 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 sortieavec des variables des types primitifs nous pouvons écrireint count = 150;

...

cout << "count = " << count << endl;

nous voulons pouvoir faire pareil pour les objets de la classe Pointcout << "target = " << target << endl;



Surcharge de l'opérateur de sortie (suite)et que sur l'écran apparaîssetarget = [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>


...

private:...

};

extern ostream& operator<<(ostream& stream,const Point& aPoint);



Fonctions membres inlineArguments par défautLe pointeur thisSurcharge des opérateursFonctions amies Données membres statiques Fonctions membres statiquesRésumé


Fonctions amiesFonctions amies

La fonction non-membre opérateur << a besoin des valeurs des coordonnées x et y d'un objet PointElle 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 membresMais les attributs sont privés, donc inaccessibles pour une fonction non-membre de la classeEn C++ on peut définir des fonctions (ou des classes) amiesd'une classe


Fonctions amies (suite)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 classeLes fonctions (ou classes) amies sont déclarées comme telles dans l'interface de la classe


Fonctions amies (suite)Fonctions amies (suite)#include <iostream>


// Constructors/Destructor...

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



Avantagesmoyen de contourner les mécanismes de contrôle d'accèsutile 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énientsmoyen de contourner les mécanismes de contrôle d'accèsfort couplage entre les classes (fonctions) amiesmodifications peuvent être difficiles



Fonctions membres inlineArguments par défautLe pointeur thisSurcharge des opérateursFonctions amiesDonnées membres statiquesFonctions membres statiques Résumé


Données membres statiquesDonnées membres statiques

Il est parfois nécessaire de partager une même valeur par tous les objets d'une classe

une conditionun compteur associé à la classe qui est modifié au fur et à mesure que l'exécution du programme se poursuitune 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)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 Pointceci est modélisé comme une donnée membre statique


...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'objetLes mécanismes de contrôle d'accès sont aussi respectésQuel 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 constantesNous 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 (fichierPhysicalConstants.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 safeif (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_);}


Fonctions membres statiques (suite)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èreDe la même façon que l'on définit des données membres (constantes ou pas), on peut définir des fonctions membres statiquesUne fonction de ce type est associée à la classe et non pas à une instance

pas de référence implicite ou explicite au pointeur thisl'appel à une de ces fonctions suppose une syntaxe particulière




//Constructors/Destructor...

// Selectorsstatic 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 variePoint p(15.0, 45.0);


<< Point::numberOfInstances()

<< endl;


RésuméRésumé

Les fonctions inline permettent de remplacer les appels aux fonctions membres tout en conservant l'encapsulationOn 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 thisLes opérateurs arithmétiques et logiques peuvent être redéfinis pour chaque classe créée par le programmeurLes fonctions et classes amies offrent un moyen de contourner le contrôle d'accèsDes données et fonctions globales à une classe peuvent être définies

partie 9: fonctions membres — programmation orientée objet en c++

Technology