Chapitre IV Les propriétés des fonctions membres

Toutes les possibilités offertes par C++ pour les fonctions restent valables pour les fonctions membres (surcharge, arguments par défaut, …)

Exemple 4.1

On désir munir la classe point d'un constructeur qui permet de créer le point :

: (EXP04_01.CPP)

• (0,0) si aucun argument n'est fourni • (abs,0) si on lui fournit abs comme seul argument • (abs,ord) si on lui fournit les deux arguments abs et ord

Pour cela, il suffit de définir le constructeur de la classe avec des paramètres par défaut class point { int x; int y; public: point(int = 0, int = 0); … … } point::point(int abs, int ord){

x = abs; y = ord; }

Les propriétés des fonctions membres 28

Exemple 4.2On désire maintenant que le constructeur de la classe point crée le point

: (EXP04_02.CPP)

• (abs,abs) si on lui fournit un seul argument (abs) Dans ce cas, on ne peut pas utiliser des valeurs par défaut, il faut par suite surcharger le constructeur : class point { int x; int y; public: point(); point(int); point(int,int); … … } point::point() { x = 0; y = 0;} point::point(int abs) {x = abs; y = abs;} point::point(int abs, int ord){ x = abs; y = ord;}

IV.1 Objets transmis en argument • Considérons une classe T et une fonction F dont l'un des paramètres est un objet de T

transmis par valeur, par adresse ou par référence. Soit U une instance de T transmis en argument à F, alors:

1. Si F est une fonction membre de T, elle aura accès à tous les membres données de U, sinon elle n'aura accès qu'aux membres publiques de U

2. Si la transmission de U se fait par valeur, il y a recopie des membres données de U dans un emplacement locale à F, ce qui entraîne certaines problèmes si la classe contient des pointeurs

Exemple 4.3

Définir une fonction qui permet de comparer deux instances de la classe point. Cette fonction devra retourner "true" si les deux objets coïncident et "false" sinon.

: (EXP04_03.CPP)

La comparaison nécessite l'accès aux coordonnées des points, qui sont des données privés, par suite, la fonction doit être une fonction membre de la classe

La déclaration de la fonction dans la classe sera : bool coincide(point)

et sa définition bool point::coincide(point pt) { return ( (pt.x == x) && (pt.y == y)); }

• On peut prévoir pour cette fonction une transmission par adresse ou par référence.

Les propriétés des fonctions membres 29

IV.2 Objets fournis en valeur de retour • Etant donné une classe T et une fonction F qui a l'une des formes suivantes :

T F(arguments); // retour par valeur T * F(arguments); // retourne l'adresse T & F(arguments) // retourne une référence

Alors F aura accès à tous les membres de l'objet retourné si elle est une fonction membre de T, si non elle n'aura accès qu'aux membres publics de la classe.

Exemple 4.4

On désire définir la fonction symetrique() qui permet de retourner le symétrique d'un point.

: (EXP04_04.CPP)

Cette fonction doit être une fonction membre de la classe point, puisqu'elle doit accéder aux coordonnées du point, qui sont des données privées. La valeur de retour sera de type point La déclaration de la fonction dans la classe sera :

point symetrique();

et sa définition point point::symetrique(){ point pt; pt.x = -x; pt.y = -y; return pt; }

IV.3 Le pointeur this • Dans une fonction membre, this représente un pointeur sur l'instance ayant appelé

cette fonction • this est un pointeur constant, c'est-à-dire qu'on ne peut le modifier.

Exemple 4.5class point {

: (EXP04_05.CPP)

int x; int y; public: point(int=0, int=0); void affiche(); }; point::point(int abs, int ord) { x = abs; y = ord;} void point point::affiche() { cout << " le point : (" << this->x << "," << this->y << ")" ; cout << " est à l'adresse " << this << endl; }

la fonction membre affiche() de la classe point affiche les coordonnées de l'objet et de son adresse.

IV.4 Fonctions membres en ligne • Toute fonction membre définie dans sa classe (dans la déclaration de la classe) est

considérée par le compilateur comme une fonction inline. Le mot clé inline n'est plus utilisé.

Les propriétés des fonctions membres 30

Dans l'exemple suivant, le constructeur de la classe point est défini en ligne class point { int x; int y; public: point(int abs = 0, int ord =0){

x = abs; y = ord;} void affiche(); };

IV.5 Fonctions membres statiques • On distingue deux types de membres :

♦ Membres d'instance : membres associés à une instance de la classe. ♦ Membres de classe : membres associés à la classe et qui ne dépendent d'aucune

instance de la classe.

• Les membres de classe, sont aussi dits membres statiques. Ils sont déclarés avec l'attribut static, et existent même si aucun objet de la classe n'est crée.

• Ainsi on peut définir un membre donnée statique comme on peut définir une fonction membre statique. L'accès à ces membres se fait avec l'opérateur de résolution de portée (::) précédé par le nom de la classe ou d'un quelconque objet de la classe

Exemple 4.6

Dans cet exemple, on prévoit dans la classe point un membre donnée statique privé nb_obj et une fonction membre NbObj() qui retourne le nombre d'instances crées.

:

Interface: (POINT2.H) #ifndef POINT_H #define POINT_H class point{ int x; int y; static int nb_obj; public: point(int = 0, int = 0); ~point(); void affiche(); static int NbObj(); }; #endif

Corps de la classe: (POINT2.CPP) #include "point2.h" #include <iostream> // utilisé dans affiche() using namespace std; //--- definition obligatoire du membre donnée statique int point::nb_obj; //--- constructeur point::point(int abs, int ord){ x = abs; y = ord; nb_obj++; } //--- Destructeur point::~point(){

Les propriétés des fonctions membres 31

nb_obj--; } //--- affiche void point::affiche(){ cout << "(" << x << "," << y << ")" << endl; } //--- definition de la fonction membre statique int point::NbObj(){ return nb_obj; }

Programme test: (EXP04_06.CPP) #include "point.h" #include <iostream> using namespace std; int main() { / Acces à la fonction membre statique avant la création des objets cout << "Nombre de points : " << point::NbObj() << endl; // Appel de la fct membre statique en utilisant un objet point a; cout << "Nombre de points : " << a.NbObj() << endl; return 0; }

IV.6 Les fonctions membres constantes • Les objets, comme les autres types de C++, peuvent être déclarés constants avec

l'attribut const. Dans ce cas, seules les fonctions membres déclarées et définies avec l'attribut const peuvent être appelées par des objets constants.

Plus précisément : class T { … … public: … type_a F(…); // fct membre ordinaire type_b G(…) const; // fct membre constante type_c K(const T); // fct avec argument constant }; // déclarations T u; // instante non constante const T v; // instante constante // appels u.F(…) // OK v.F(…) // erreur : instance constante u.G(…) // OK v.G(…) // OK // T w; u.K(v) // OK u.K(w) // OK v.K(w) // erreur : instance constante et fct non constante

v est une instance constante, donc elle ne peut être appelée ni par F ni par K, qui ne sont pas des fonctions constantes

Les propriétés des fonctions membres 32

Exemple 4.7Cet exemple montre la différence entre les variables simples et les objets lors de passage en arguments à des fonctions demandant des arguments constants et la différence d'une fonction membre et une fonction non membre agissant sur des objets constants.

: (EXP04_07.CPP)

#include <iostream> using namespace std; //----------------------------------------------------------------- class point{ int x; int y; public: point(int abs = 0, int ord = 0){ x = abs; y = ord; } void affiche() const; // fct membre constante bool coincide(const point); // argument constant void deplace(int,int); }; void point::affiche() const{ cout << "(" << x << "," << y << ")" << endl; } bool point::coincide(const point pt){ return ( (pt.x == x) && (pt.y == y) ); } void point::deplace(int dx, int dy){ x =+ dx; y =+ dy; } //----------------------------------------------------------------- // fonction avec argument constant de type simple void fct(const int k) { cout << k << endl; } // fonction avec argument constant de type classe point sosie(const point pt) { return pt; } //----------------------------- TEST int main() { // Cas d'une fonction simple avec argument de type simple int i = 5; const int j = 10; fct(i); // OK fct(j); // OK // ----------------------Cas des objets point a; const point b(5,6); //-----Appel d'une fonction non membre point c; c = sosie(a); // OK c = sosie(b); // OK //-----Appel d'une fonction membre non constante a.deplace(1,1); //b.deplace(1,1); // erreur : instance constante, fonction non constante //-----Appel de la fonction membre constante cout << "a = " ; a.affiche();

Les propriétés des fonctions membres 33

cout << "b = " ; b.affiche(); cout << endl; //-----Appel de la fonction membre non constante avec paramètres constants // instance non constant, argument constant cout << ( a.coincide(b) ? "coincident" : "ne coincident pas" )<< endl; // instance non constante, argument non constant cout << ( a.coincide(a) ? "coincident" : "ne coincident pas" )<< endl; // instance constante, fonction non constante : ERREUR //cout << ( b.coincide(a) ? "coincident" : "ne coincident pas" )<< endl; return 0; }

Les propriétés des fonctions membres 34