Vous êtes sur la page 1sur 4

CLASSES AVEC OBJETS MEMBRES :

L’initialisation d’un objet de la classe nécessite l’initialisation de ces objets membres.

exemple :

class Point { int x; int y; … };


class Segment { Point origine;
Point extrémité;
int lg;
public:
segment(int ox, int oy, int ex, int ey, int l) :
origine(ox, oy), extremite(ex, ey)
{lg = l}
};

Cette dernière partie peut aussi s’écrire sous la forme :

origine(ox, oy), extremite(ex, ey), lg(l) {};

Il s’agit d’une initialisation des données membres qu’elles soient objets ou primitives.
On peut aussi définir le constructeur de la classe “Segment” de la manière suivante :

Segment:: Segment(Point o, Point E, int l)


{origine(o.getx(), o.gety() );
extremite(E.getx(), Egety() ); lg =
l; }
On peut aussi écrire :
: origine(o.getx(), o.gety(), extremite(E.getx(),
E.gety() ); lg(l) { }

DESTRUCTEURS :

C’est une fonction membre spéciale ayant le même nom que la classe
précédée du signe “~” .
Il est invoqué lorsqu’un objet de la classe est détruit .

exemple :

class Point{int x,y;


char * etiquette;

~Point(){ delete[]etiquette ;}
};
MEMBRES CONSTANTS :

Une donnée membre peut être qualifiée const, et elle doit être obligatoirement
initialisée lors de la construction de l’objet, sa valeur ne pourra plus être modifiée par
la suite.

exemple :
class Point{int x; int y;
const int numero;
public : Point(int a , int b, int n):
x(a), y(b), numero(n){}
};

remarque :
La définition suivante du constructeur provoque une erreur.

point::Point(int a, int b, int n)


{x = a; y = b; numero = n;}

erreur : modification de la donnée const


(affectation à la constante)

Il faudrait écrire “numero(n)” qui s’agit d’une initiation.

FONCTIONS MEMBRES CONST :

Il s’agit des fonctions membres qui ne modifient pas l'état de l’objet qui les invoque.

exemple :
class Point{int x,y;

public: void deplacer(int dx, int dy)
{x += dx; y +=dy;}
int getx()const {return x;}
int gety()const {return y;}
… };

remarques :
● Le qualificatif const fait partie de la signature d’une fonction.
● on peut donc surcharger une fonction membre non const avec une fonction membre
const .
exemple :
class Point{int x,y;
public : int getx()const{return x;}
int gety()const{return y;}
int & getx(){return x;}
int & gety(){return y;}
};
const Point p(1,2);
Point q(15,3);
int a;
a = p.getx();
p.getx() = a; //erreur p est const
a = q.getx();
q.getx() = a; //q.getx() est une référence

FONCTIONS MEMBRES STATIQUES :

● Une fonction membre statique n’est pas attachée à un objet.


● Une fonction membre statique ne dispose pas de pointeur “this”.
● De sa classe, elle référence uniquement les membres statiques (fonctions
et données).

exemple :
class Point{int x,y;
static int nbpts;
public : static int combien()
{return nbpts;}
Point(int a, int b)
{ x = a; y = b; nbpts++; }
… };
Point a; …
cout << a.combien();
cout << Point::combien();
➔ Afficher le nombre de points ( nbpts est privée ).

FONCTIONS AMIES :

Une fonction amie d’une classe est une fonction qui n’est pas membre à la
classe, mais elle a le droit d'accéder à tous ses membres.

exemple :
class Test{int x;
friend void ajuster(Test & t, int
à; … };
void ajuster(Test & t, int a)
{t.x = a;}
main(){Test t;
ajuster(t,2);}
CLASSES AMIES :

Une classe amie à une classe donnée, est une classe qui a le droit d'accéder à
tous les membres de la dite classe.

Vous aimerez peut-être aussi