Vous êtes sur la page 1sur 54

Chapitre 6

La Couche objet
Dr LAHBIB Younes

04/12/2009 couche objet 1


plan
• Classe et objets
• Les constructeurs
• Les constructeurs par copie
• Les OBJETS membres
• Les Méthodes constantes
• Pointeur THIS

04/12/2009 couche objet 2


CLASSE ET OBJETS

04/12/2009 couche objet 3


Principe de la POO

Les objets interagissent entre eux par les fonctions dans la POO
déc.-09 4
Classes et objets: introduction

déc.-09 5
Objets
OBJECTS – utilisés pour modéliser des entités réelles:
personnes place vecteur
personnes, vecteur, temps
temps, liste …
Comment définir un objet ?
Chaque objet peut être définie pour contenir des
données et des fonctions manipulant ces données.

déc.-09 6
Classes et Objets
• Programmation Orientée Objet : les données et les traitements sont
regroupés dans des entités informationnelles appelées objets
⇒ le programme est vu comme une collection d’objets
d objets distincts.
distincts

• Une classe est une description d’un ensemble d’objets ayant une
structure
t t de
d données
d é commune ett disposant
di t des
d mêmes
ê fonctionnalités.
f ti lité

• Avantages
g de l’approche
pp O.O. :
– Facilité de conception et réutilisation de code
– Fiabilité
– Facilité de compréhension
– Encapsulation : la structure interne d’un objet et l’implémentation de
ses méthodes sont invisibles aux utilisateurs
⇒ masquage d’informations
⇒ la communication est faite seulement par l’appel de ses méthodes
⇒ protection des données
04/12/2009 couche objet 7
Avantages de l’approche P.O.O. :

– Facilité de conception et réutilisation de code

– Fiabilité

– Facilité de compréhension

– Encapsulation : la structure interne d’un objet


j et l’implémentation de
ses méthodes sont invisibles aux utilisateurs

⇒ masquage d’informations
d informations

⇒ la communication est faite seulement par l’appel de ses méthodes

⇒ protection des données

04/12/2009 couche objet 8


Définition d’une Classe
Données membres: définissent la structure
• Une classe est interne des instances (leurs états)
définie par
Fonctions membres: définissent le
comportement des instances (agissent sur
ses attributs)

• Visibilité au sein Partie Publique (Public) : accessible aux


d’une
d une classe utilisateurs de l’objet
l objet

Partie Protégée (Protected) : accessible aux


classes dérivées

Partie Privée (Private): accessible seulement


à l’intérieur
l intérieur de la classe (cachée aux
utilisateurs)

Remarque:
q En O.O p
pure,, tous les attributs de la classe doivent être p
privés
(encapsulés). Cependant, C++ permet de déclarer des attributs publiques.

04/12/2009 couche objet 9


Syntaxe de classe

class nom_classe
{
private:
….. //membres privés
protected:
…… //membres protégés
p g
public:
…… //
//membres p
publique
q
};

04/12/2009 couche objet 10


Exemple de classe
class point
{ p private:
int absc, ord;
p
public:
void initialiser ()
{ absc = 0; ;
ord = 0;
}
void afficher()
{
cout<<″(″<<absc<<″,″<<ord<<″)″;
}
04/12/2009 }; 11

couche objet
LES CONSTRUCTEURS

04/12/2009 couche objet 12


Les Constructeurs: principe
• Constructeur : méthode membre appelée lors de la création d’objets instances de
classe. Son rôle :

– Initialisation des attributs de l’objet

– Allocation dynamique
y q

– Autre traitements (affichage, modification de variables globales ou statiques,


etc))

• Constructeur par défaut : fourni par le compilateur C++ en cas d’absence


d absence d’un
d un
constructeur dans la classe. Son rôle :

– Allocation statique des attributs de l’objet


l objet

– Relier l’objet à ses méthodes

04/12/2009 couche objet 13


Les Constructeurs: caractéristiques

Les constructeurs sont des fonctions membres spéciales car :

- Portent le même nom que la classe

- Pas
P ded type
t de
d retour
t

- Peuvent être surchargées


g

- Appelée d’une manière spéciale

04/12/2009 couche objet 14


Syntaxe Constructeur

class nom_classe
{
private :
. . . .
public :
nom_classe( . . . )
{
. . . . . liste des paramètres formels
}
} ;

04/12/2009 couche objet 15


Appel
pp du constructeur

1. Allocation statique de l’objet


nom_classe nom_obj(. . . . .) ;
liste des paramètres effectifs

ou encore

2. All
2 Allocation
ti dynamique
d i de
d l’objet
l’ bj t
nom_classe * ptr = new nom_classe(. . . . .) ;

04/12/2009 couche objet 16


Constructeurs: exemple
class StudentRecord
{
private:
i t
int SSN;//ATTRIBUTES
char first_name[20], last_name[20], address[40],
grade;
public:
StudentRecord(int SSN);//Constructor
- -
- -
};

StudentRecord::StudentRecord(int SSN)//Constructor Definition


{
this->SSN
t s SS = SSSSN;
;
}

déc.-09 17
Passage des arguments au
constructeurs

• Quand déclarer une instance:


ClassName instance(arg1, arg2, …);

• Quand utiliser l’opérateur new:


className * ptr;
ptr = new ClassName(arg1, arg2, …);

déc.-09 18
Exemple 1
class point
{ private:
int absc, ord;
public:
point (int x =0, int y=0)
{ absc = x;
ord = y;
}
…….
};

Void main()
{
point p1; // p1(0, 0)
point p2 (3, 5); //p2(3, 5)
point * ptr = new point (7, 8);
}

04/12/2009 couche objet 19


Exemple 2
class pile
{ private:
int tete, taille;
int * tab;
public:
pile (
p (int n)
)
{ tete = -1;
taille = n;
tab = new int [n];
}
…….
};

Void main()
{
pile p1 (10);
pile p2; //Erreur, pas de constructeurs non paramétré
dans la classe
}
04/12/2009 couche objet 20
Constructeurs: Remarque 1

• Si un constructeur a un seul paramètre, il peut être initialisé


par l’affectation
l’ ff t ti
Exemple 1:

pile p1(10); est équivalent à


pile p1 =10;

Exemple 2:
pour les types standard C++ le constructeur par affectation est appelé.
C i estt dû au surcharge
Ceci h d
de l’l’opérateur
é t = (à voir
i plus
l lloin)
i )

int x (3) ; est équivalent à


int x= 3

04/12/2009 couche objet 21


Constructeurs: Remarque 1

• Quand on veut créer un objet temporaire, on appelle le


constructeur sans le nom d
d’objet
objet
class complexe
{
private :
float re, im; void main()
public: {
Complexe (float x =0, float y =0)
{ Complexe c1 (4, 5), c2;
re=x; im = y; C2=c1.Add(Complexe (2,3);
}
}
Complexe Add(Complexe C)
{
return Complexe (re+ c.re, im + c.im);
}
};
04/12/2009 couche objet 22
Les Destructeurs

• Destructeur : méthode membre appelée lors de la libération


d’objets instances de classe. Son rôle :

– Libération
Libé ti desd attributs
tt ib t alloués
ll é d dynamiquement
i t

– Autre traitements reliés à la suppression


pp de l’objet
j
(affichage, annuler des modifications sur des variables
globales
l b l ou statiques,
t ti etc)
t )

• Destructeur p
par défaut : fourni p
par le compilateur
p C++ p
pour
libérer les attributs statiques de l’objet

04/12/2009 couche objet 23


Les Destructeurs: remarques

Remarque1 : Dans certains cas cas, le destructeur est


insuffisant pour détruire l’objet et un destructeur doit être
implémentée dans la classe.

Remarque2 : Les destructeurs sont des fonctions


membres spéciales car :
-Portent le même nom que la classe précédé par le symbole
~
-Pas de type de retour
-Pas de paramètres
p
-Appelées automatiquement

04/12/2009 couche objet 24


Cycle de vie d’un objet

Création de l’instance

Constructeur

Objet vit

Destructeur

Destructeur par défaut

Objet détruit

04/12/2009 couche objet 25


• Syntaxe Destructeur Exemple 1

class nom_classe class point


{ private:
{
int absc
absc, ord;
private :
public:
.... point (int x =0, int y=0)
public : { absc = x;
~nom_classe() ord = y;
{ }
.....
} ~point ()
}; { cout<<″objet détruit ″;
}
…….
};

04/12/2009 couche objet 26


Exemple 2
Objet
Pile p1
class pile
taille
{ private:
int tete, taille; Libérés
Libé é par lle
destructeur par défaut
tete
int * tab;
public: tab
pile (int n)
{ tete = -1;
…….
t ill = n;
taille
Libérés par le destructeur
tab = new int [n]; implémenté
}
~pile()
{ delete [ ] tab;}

…….
};

04/12/2009 couche objet 27


LES CONSTRUCTEURS PAR
COPIE
04/12/2009 couche objet 28
Les Constructeurs par copie ?
• Constructeur par copie: méthode membre appelée lorsqu’on veut créer un objet
par copie d’un autre objet de même classe.

• Il est appelé automatiquement (implicitement) dans 2 cas :


– Un objet est transmis comme paramètre dans une fonction avec le passage
par copie de valeur
Exemple
void fct (point p2) void main()
{……} { point p1(3, 5);
fct (p1);}
Appel implicite du
constructeur ppar copie
p p pour
générer une copie p2 de p1
– Un objet est retourné comme valeur de retour d’une fonction
Exemple
point g( ) Retour d’une copie de p
{ point p(3, 5);
……
return p;
04/12/2009 } 29
Les Constructeurs par copie PAR DEFAUT
• Constructeur par copie par défaut: il est créé par le compilateur C++ en cas
d’absence d’un constructeur par recopie implémentée dans la classe.

⇒ il exécute une copie


p bit à bit

⇒ le nouvel objet est une copie exacte de l’objet d’origine


Remarque: dans certains cas, il peut causer des problèmes (voir exemple)
Exemple
Objet Objet
Pile p1 Pile p2
Taille 20 T ill 20
Taille
copie
Tete 2 Tete 2

tab tab

…….

P blè
Problèmes d
de modification
difi ti
04/12/2009 couche d’objet
Problèmes de libération objet 30
• Syntaxe Constructeur par copie

class nom_classe
{
private :
....
public :
nom_classe( const nom_classe & obj )
{
.....
}
};

04/12/2009 couche objet 31


Exemple 1
class pile
{ private:
i
int tete, taille;
int * tab;
pub c:
public:
pile (const pile & p)
{ tete = p.tete;
taille = p.taille;
t b = new int
tab i t [taille];
[t ill ]
for (int i = 0; i<= tete; i++)
tab[i]= p.tab[i];
}
…….
};

Void
V id main()
i ()
{
pile p1 (10);
…..
pile p2 (p1);// appel explicite du constructeur par copie pour
//créer p2 à partir de p1
}

pile p2 = p1;
couche objet 32
LES OBJETS MEMBRES

04/12/2009 couche objet 33


Les Objets Membres
• Les attributs d’une classe peuvent être des instances d’autres
classes ⇒ On parle d’objets membres d’une classe

Syntaxe

class
l A class
l B class
l C
{ { {
private : private : private :
.... .... A a;
public : public : Bb;
A(…. ) B(…. ) public :
{. . . . . } {. . . . . } C(…. ):a (….), b(….)
~A()
A() ~B()
B() { .... }
{.
{………} {………} ~C()
}; }; {
{………} }
04/12/2009 couche objet }; 34
• Le constructeur de la classe C appelle les constructeurs des
classe A et B pour construire respectivement les objets
membres a et b.

• Le destructeur de la classe C appelle automatiquement les


destructeurs de A et B pour libérer a et b.

Exemple : Implémenter la classe rectangle définie par deux


points
p2

p1

04/12/2009 couche objet 35


//Interface de classe //implémentation des méthodes
class
l point
i t
{ point::point(int x,int y)
{ abs=x;ord=y; }
private:
int abs,ord;
public: void point::deplacer(int dx,int dy)
point(int,int); { abs+=dx;ord+=dy;
abs dx;ord dy; }
~point(){}

int g
getx();
(); int p
point::getx()
g ()
int gety(); { return abs; }
void affiche();
void deplacer(int
deplacer(int,int);
int);
int point::gety()
};
{ return ord; }

void point::affiche()
{ cout<<"(abs="<<abs<<",ord"<<ord<<")"; }

04/12/2009 couche objet 36


//Interface de classe
class rectangle
{
private:
point p1,p2;
public:
rectangle(int,int,int,int);
rectangle(point,point);
g p ,p
rectangle(point,int, int);
~rectangle();
rectangle(const rectangle &);
void deplacer(int,int);
void afficher();
};

04/12/2009 couche objet 37


implémentation des méthodes

rectangle::rectangle(int x1,int y1,int x2,int y2):p1(x1,y1), p2(x2,y2)


{ }

rectangle::rectangle(point a,point b):p1(a),p2(b)


{ }

rectangle::rectangle(point a, int lar, int haut):p1(a), p2(a.getx()+lar,


a.gety()+haut)
{ }

rectangle::~rectangle(){ }

rectangle::rectangle(const rectangle &r):p1(r.p1),p2(r.p2){ }

04/12/2009 couche objet 38


void rectangle::deplacer(int dx,int dy)
{
p1.deplacer(dx,dy);
p2.deplacer(dx,dy);
}

void rectangle::afficher()
{
p1.affiche();
p2.affiche();
}

void main()
{
point p(0,0);
rectangle r(1,1,100,200);
r.deplacer(10,20);
r.affiche();
}

04/12/2009 couche objet 39


LES MÉTHODES
CONSTANTES
04/12/2009 couche objet 40
Méthodes constantes

• Les méthodes constantes sont généralement les méthodes qui ne


modifient pas l’état de l’objet (les valeurs de ses attributs).

• Les objets constants ne peuvent appeler que les méthodes constantes.


Ces méthodes sont distinguées par le qualificateur const.

Syntaxe
class nom_classe
{
. . . .
Type-retour nom_methode ( . . . . ) const
{ . . . . }

};

04/12/2009 couche objet 41


class point
Exemple
{ void main()
private: {
int abs,ord; point p1(3, 5);
public:
bli const point p2(20, 10);
point(int,int); p1.afficher() ; //valide
p2.afficher() ;//valide
~point(){}
point(){}
p1.deplacer() ; //valide
void deplacer(int,int); p2.deplacer() ;//Erreur
}
int getx();
int gety();
void affiche()const;

};

void point::affiche()const
{
cout<<”(”<<abs<<”,”<<ord<<”)” ;
}
04/12/2009 couche objet 42
POINTEUR THIS

04/12/2009 couche objet 43


Lien entre Classes et objets

déc.-09 44
Classes et objets:
j p
pointeur « this »
• « This » pointe sur l’objet de la classe elle-même.
• La fonction membre peut trouver l’adresse
l adresse de ll’objet
objet
auquel elle appartient

/* Function
F i taking
ki an object
bj off type signal
i l as an argument.*/
*/
void bind(signal s);
[…]
class signal
{

void bindme( )
{ // signal * s; bind(*s);
bind(*this);
bind( this); // *this
this is the current object which
// is of type signal
}
}
déc.-09 45
Pointeur « this » (suite)
( )
• Peut être utilisé pour entrer un argument et une variable de
classe:

class A {
int x = 3;
void f(int x) {
cout << "x= " << x << ", this->x= " << this->x << endl;
}
};

int main() {
A instance;
instance.f(1); // x= 1, this->x= 3
}

déc.-09 46
POLYMORPHISMES DES
FONCTIONS
04/12/2009 couche objet 47
Polymorphisme
y p de fonction
Exemple de surcharge de la fonction add() suivante:

/* The correct function to be invoked is determined by checking the number


and type of argument*/

//Declarations
int add(int a,int b); //prototype 1
i
int add(int
dd(i a,int
i b i
b,int c);
) //prototype
// 2
int add(double a,int b); //prototype 3
//Function calls
cout<<add(5,10) //uses prototype 1
cout<<add(5,10,20) //uses prototype 2
cout<<add(0.72,10) //uses
// prototype 3

déc.-09 48
EXERCICES

04/12/2009 couche objet 49


Exercices
1. Définir une classe Ensemble permettant d’implémenter un
ensemble d’entiers.
La classe utilise un tableau d’entiers
d entiers d’une
d une taille donnée et
possède les méthodes suivantes :

– Constructeur : crée et initialise un ensemble vide d d’une


une taille
max donnée
– Constructeur par recopie
– Destructeur
– Ajoute : ajoute un entier à l’ensemble s’il n’existe pas déjà
– appartient : vérifie si un élément appartient ou non à
l’ensemble
– Inclut : vérifie si un ensemble est inclut ou non à l’ensemble
– Intersection : retourne l’intersection
l intersection de deux ensembles
– Union : retourne l’union de deux ensembles
– Affiche : affiche les éléments de l’ensemble
04/12/2009 couche objet 50
Le programme suivant continent
un BUG à déterminer

04/12/2009 couche objet 51


04/12/2009 couche objet 52
04/12/2009 couche objet 53
04/12/2009 54