Proprits des membres dune classe

Plan du chapitre :
I. Autorfrence : (oprateur this) .... 44 II. Membres constants ... 45 III.Membres statiques .... 47 IV. Les fonctions amies ...
50

Objectifs du chapitre :
Manipuler loprateur this. Manipuler les membres (attributs et mtodes) constants et celle statiques lintrieur dune classe. Comprendre la notion damiti et son utilisation dans le langage C++.
44

Proprits des membres dune classe

I. Autorfrence : (oprateur this) :

Lautorfrence ou bien accs sois mme: lorsque lon a besoin de pointer lobjet lintrieur de la classe mme, C++ a prvu le mot cl this. This est utilisable uniquement au sein dune fonction membre et dsigne un pointeur sur lobjet layant appel.
#include <iostream> using namespace std ; class Points { public : void afficher() { //Notation Inutile avec this cout <<this->x<<','<<this->y<<endl; } void placer (int a ,int b) { x=a; y=b; } bool PointEgal (Points *p) { return(p==this); } bool PointCoincidant(Points *p) { return ((p->x==this->x)&&(p->y==this->y)); }

44

Proprits des membres dune classe

public: int x; int y; };

Utilisation dans le fichier main.cpp :

#include <iostream> using namespace std ; #include "Points.cpp" void main() { Points *p=new Points; Points *p1=new Points; p1->x=1; p1->y=15; p->x=10; p->y=20; p->afficher(); p->placer(1,5); p->afficher(); if(p1->PointEgal(p)) cout adresse"; if(p1-> PointCoincidant (p)) cout contenu"; <<"p1 et p ont le mme <<"p1 et p ont la mme

II. Membres constants:

I.1. Attributs Constants:
Une donne membre dans une classe peut tre qualifie const. Il est alors obligatoire de linitialiser lors de la construction dun objet, et sa valeur ne pourra pas tre modifie la suite. 44

Proprits des membres dune classe

Voici un programme que lon va tester:

class Segment{ Point origine; //Objet membre

Point extremite; //Objet membre int epaisseur; const int numeroDeSerie; // membre constant public: Segment(int ox,int oy,int ex,int ey,int ep,int num): origine(ox,oy),extremite(ex,ey) { epaisseur=ep; } };

A la compilation, on obtient le message derreur suivant :

error C2758: 'numeroDeSerie' : must be initialized in constructor base/member initializer list

Commentaires: Le compilateur oblige dcrire au moins un constructeur. Le constructeur explicite doit initialiser lattribut constant.

Voici la version correcte du programme:

class Segment{ public : Point origine; //Objet membre

Point extremite; //Objet membre int epaisseur; const int numeroDeSerie; // membre constant public: Segment(int ox,int oy,int ex,int ey,int ep,int num): origine(ox,oy),extremite(ex,ey),numeroDeSerie(num ) { epaisseur=ep; }

44

Proprits des membres dune classe

};

Mais Attention vous ne pouvez pas faire ceci au programme principal :

#include "Point.cpp" void main() { Segment s=Segment(0,1,2,5,10,200); s.numeroDeSerie=200; } // erreur de compilation.

I.2 Fonctions constantes:

En C++ on peut dfinir des objets constants, dans ce cas lutilisateur doit prciser parmi les fonctions membres, lesquelles sont autorises oprer sur des objets constants. Il le fera en utilisant le mot const dans leur dclaration. Cest une manire de dire quil sagit dune fonction de consultation de lobjet et non dune fonction de modification. Comme dans cet exemple de dfinition dune classe point :
class Point{ public: int x, y; Point(int px,int py) { x=px; y=py; } void deplacer(int a,int b) { x+=a; y+=b; } void afficher() const { cout <<x<< ","<<y<<endl ; } }

44

Proprits des membres dune classe

Le fait de spcifier que la fonction afficher est constante a deux consquence : Elle est utilisable pour un objet dclar constant.

Ainsi avec ces dclarations :

Point a ; const Point c ;

Les instructions suivantes seront correctes :

a.afficher() ; c.afficher() ; a.deplacer(1,1) ;

En revanche, celle-ci sera rejete par le compilateur :

c.deplacer(1,1) ;//incorrecte, c est constante

Les instructions figurant dans sa dfinition ne doivent pas modifier la valeur des membres de lobjet point :
class Point{ public: int x,y ; void afficher() const { x++ ;//erreur ca affiche est constante } }

Remarque :
Il est possible de surdfinir une fonction membre en se fondant sur la prsence ou labsence du qualificatif const. Ainsi dans la classe point prcdente nous pouvons dfinir ces deux fonctions :
void afficher() const ; //afficher I void afficher() ; //afficher II

Avec ces dclarations :

Point a ; const Point c ;

44

Proprits des membres dune classe

linstruction a.afficher() appellera la fonction II alors que c.afficher() appellera la fonction I. Pour pouvoir dclarer un objet constant, il faut tre sur que le concepteur de la classe correspondante a t exhaustif dans le recensement des fonctions membre constantes. Dans le cas contraire, on risque de ne plus pouvoir appliquer certaines fonctionnalits un tel objet constant.

III.Membres statiques:
Normalement, chaque objet dune classe possde son propre exemplaire de chaque membre ordinaire (nous dirons membre non statique) : - Pour les attributs membres cela signifie que la mmoire nouvelle est alloue lors de la cration de chaque objet. - Pour les fonctions membres, cela veut dire quelles ne peuvent tre appeles quen association avec une instance de la classe.

III.1. Attributs statiques:

Un attribut static :
obit aux rgles daccs des attributs ; est partag par toutes les instances la classe ; est cr et initialis avant le main() ; sa dfinition se fait dans la partie globale du programme.

Par exemple si nous avons dfini une classe exple1 par :

class exple1 { int n; float x; ... };

une dclaration telle que:

exple1 a, b ;

conduit a une situation que lon peut schmatiser ainsi : a.n a.x b.n b.x

Objet a Objet b Pour un attribut statique, si nous dfinissons une classe exple2 par :
class exple2

44

Proprits des membres dune classe

{ static int n; float x; ... };

la dclaration:
exple2 a, b ;

conduit une situation que lon peut schmatiser ainsi : a.n a.x Objet a Objet b On peut dire que les membres donnes statiques sont des sortes de variables globales dont la porte est limite la classe. Initialisation des membres statiques : Un membre statique doit tre initialis explicitement lextrieur de la dclaration de la classe par une instruction telle que :
int exple2::n=5;

b.n b.x

Cette dmarche est utilisable ainsi bien pour les membres statiques privs que public. Par ailleurs, contrairement ce qui se produit pour une variable ordinaire, un membre statique nest pas initialis par dfaut zro.
class MonPoint { public: MonPoint(int px, int py); static nombreDePoints; private: int x; int y; };

44

Proprits des membres dune classe

#include "MonPoint.h" //initialization du membre statique int MonPoint::nombreDePoints= 20; MonPoint::MonPoint(int px, int py) { x=px; y=py; } #include <iostream> using namespace std ; #include "MonPoint.h" void main() { MonPoint *p=new MonPoint(1,2); MonPoint *q=new MonPoint(14,72); int nbstatic=MonPoint::nombreDePoints; cout <<"Nombre de points statiques :"<<nbstatic; cout <<"Nombre de points pour p:"<<p->nombreDePoints; cout <<"Nombre de points pour q:"<<q->nombreDePoints; //Changement du nombre de points statiques MonPoint::nombreDePoints=10; cout <<"nombre de points pour p:"<<p->nombreDePoints; cout <<"Nombre de points pour q:"<<q->nombreDePoints; }

Commentaires : Linitialisation du membre statique nombreDePoints ne peut pas se faire dans le fichier MonPoint.H mains dans un fichier .CPP Vrifier que toute instance de la mme classe dclare p et q donne la mme valeur. Aprs son changement MonPoint::nombreDePoints=10;dans la fonction main() 44

Proprits des membres dune classe

on vrifie que les instances prennent tous la dernire valeur change.

III.2 Mthode statique:

Une fonction membre statique nest pas attache un objet. Par consquent: Elle agit sur des donnes membres statiques. Elle ne dispose pas du pointeur this. Ces fonctions servent accder aux membres statiques. On les utilise quand il sagit dune fonction qui ne dpend pas dune instance. Son appel ncessite le nom de la classe correspondant (accompagn par ::) et elle peut mme tre appele lorsquil nexiste aucun objet de la classe.
class Point { public: MonPoint(int px, int py); static int getnbrPoints (); private: int x,y; static nbrPoints; }; #include "Point.h" int Point:: nbrPoints = 0; int Point::getnbrPoints () { return nbrPoints; } Point::Point(int px, int py) { nbrPoints ++ ; x=px; y=py; } #include <iostream> using namespace std ; #include "Point.h" void main() {

44

Proprits des membres dune classe

cout<<"Nombre de points:"<<Point ::getnbrPoints(); MonPoint P1(1,2); cout<<"Nombre de points:"<<Point ::getnbrPoints(); MonPoint P2(14,72); cout<<"Nombre de points:"<<Point ::getnbrPoints(); }

IV. Les fonctions amies:

Il est parfois ncessaire d'avoir des fonctions qui ont un accs illimit aux champs d'une classe. En gnral, l'emploi de telles fonctions traduit un manque d'analyse dans la hirarchie des classes, mais pas toujours. Elles restent donc ncessaires malgr tout. De telles fonctions sont appeles des fonctions amies. Pour qu'une fonction soit amie d'une classe, il faut qu'elle soit dclare dans la classe avec le mot cl friend. Les fonctions amies ne sont pas des mthodes de la classe cependant (cela n'aurait pas de sens puisque les mthodes ont dj accs aux membres de la classe). Il existe plusieurs situations damitis : fonction indpendante, amie dune classe. fonction membre dune classe amie dune autre classe. toutes les fonctions membres dune classe, amie dune autre classe.

IV.1. Fonction indpendante, amie dune classe :

Soit la classe point:
class Point { int x; int y; public : Point(int,int); void afficher() ; };

Nous voulons introduire une fonction coincide non membre de la classe permettant de 44

Proprits des membres dune classe

vrifier la concidence de deux objets de type point. Il sagit dune fonction amie, do il faut introduire tout dabord dans la classe point la dclaration damiti approprie :
class Point { int x; int y; public : Point(int,int); void afficher() ; friend bool coincide (point, point) ; }; bool coincide (point p, point q) { if(p.x==q.x&& p.y==q.y) return true; else return false; } void main() { Point P1(1,1), P2(2,2); if(coincide(P1,P2)) cout<<P1 coincide avec P2<<endl; else cout<<"P1 et P2 sont diffrents"<endl ; //... }

Remarques: Lemplacement de la dclaration damiti au sein de la classe point est absolument indiffrent. Il nest pas ncessaire de dclarer la fonction amie dans la fonction ou dans le fichier 44

Proprits des membres dune classe

source ou lon utilise, car elle est dj obligatoirement dclar e dans la classe concerne. Une fonction indpendante peut tre amie de plusieurs classes.

IV.2. Fonction membre dune classe amie dune autre classe :

Il sagit un peut dun cas particulier de la situation prcdente. En effet il suffit simplement de prciser, dans la dclaration damiti, la classe la quelle appartient la fonction concerne, laide de loprateur de rsolution de porte(::).
class A { // partie prive ...... // partie publique friend int B ::f(float, A) ; ...... };

class B { ...... int f(float..., A ...) ; { //on a accs ici aux membres privs de tout //objet de type A } ...... };

IV.3. Toutes les fonctions membres dune classe, amie dune autre classe :
Cest une gnralisation du cas prcdent. On pourrait dailleurs effectuer autant de dclarations damiti quil ny a de fonctions concernes. Mais il est plus simple deffectuer une dclaration globale. Ainsi pour dire que toutes les fonctions membres de la classe B sont amies de la classe A, on placera, dans la classe A, la dclaration :
friend class B ;

44

Proprits des membres dune classe

class A { // partie prive ...... // partie publique friend class B; ...... };

class B { ......

//on a accs totale aux membres privs de tout //objet de type A ...... };

44