Weitere ähnliche Inhalte
Ähnlich wie Partie 8: Objets et Classes — Programmation orientée objet en C++ (20)
Partie 8: Objets et Classes — Programmation orientée objet en C++
- 2. Vue d'Ensemble
Notions de base
Types, variables, opérateurs
Contrôle d'exécution
Fonctions
Mémoire dynamique
Qualité du logiciel
Evolution du modèle objet
Objets et classes
Fonctions membres
Classes génériques
Héritage
Polymorphisme
Héritage multiple
Entrée/sortie
POO en C++: Objets et Classes 197 © 1997-2003 Fabio HERNANDEZ
- 3. Table des Matières
Nature d'un Objet
Nature d'une Classe
Exemple: une classe simple
abstraction
définition de l'interface
utilisation
implémentation
modification
fonction membres
contrôle d'accès
initialisation/destruction
Résumé
POO en C++: Objets et Classes 198 © 1997-2003 Fabio HERNANDEZ
- 4. Nature d'un Objet
Un objet représente une entité individuelle et identifiable,
réelle ou abstraite, avec un rôle bien défini dans le domaine du
problème
Exemple: dans une usine de fabrication d'automobiles, on peut
identifier des objets tels
moteur
châssis
volant
système électrique
processus de montage
Des objets peuvent être tangibles, mais peuvent ne pas avoir
une frontière physique très bien définie (rivière, des nuages, ...)
POO en C++: Objets et Classes 199 © 1997-2003 Fabio HERNANDEZ
- 5. Nature d'un Objet (suite)
Caractéristiques d'un objet
Etat
Comportement
Identité
Etat
un attribut est une caractéristique, qualité ou trait intrinsèque qui
contribue à faire unique un objet
l'état d'un objet comprend les propriétés statiques (attributs) et les
valeurs de ces attributs
les valeurs des attributs peuvent être statiques ou dynamiques
du fait d'avoir un état, un objet occupe un espace dans le monde
physique et dans la mémoire de l'ordinateur
exemple: les attributs de l'objet point en deux dimensions sont les
coordonnées x et y
POO en C++: Objets et Classes 200 © 1997-2003 Fabio HERNANDEZ
- 6. Nature d'un Objet (suite)
Comportement
façon d'agir et de réagir d'un objet comme conséquence des
changements d'état et des opérations effectuées sur lui
représente l'activité de l'objet vue de l'extérieur
si on regarde un objet comme un serveur, son comportement est
l'ensemble des services offerts par lui à ses clients
exemple: un point peut être déplacé, tourné autour d'un autre point, etc.
le comportement dépend de l'état de l'objet et de l'opération
effectuée sur lui
l'état d'un objet représente le résultat cumulé de son comportement
Identité
propriété d'un objet qui permet de le distinguer des autres objets de la
même classe
POO en C++: Objets et Classes 201 © 1997-2003 Fabio HERNANDEZ
- 7. Nature d'une Classe
Les notions de classe et d ’objet sont étroitement liées
Une classe est un ensemble d'objets qui partagent une
structure et un comportement communs
Une classe est seulement une abstraction
Un objet est une instance (entité concrète) d'une classe en
temps d'exécution
On peut voir la classe comme un moule pour la fabrication
d'objets
Les objets fabriqués avec le même moule partagent structure
et comportement
POO en C++: Objets et Classes 202 © 1997-2003 Fabio HERNANDEZ
- 8. Nature d'une Classe (suite)
Deux vues d'une classe
interface
implémentation
Interface
vue externe abstraite d'une classe
liste de services offerts par les instances de la classe (contrat)
une opération non spécifiée dans l'interface d'une classe ne peut être
appliquée sur une instance (objet) de cette classe
cache la structure interne de la classe (encapsulation)
réponse à la question quoi
contenue dans un fichier d'entête (.h)
POO en C++: Objets et Classes 203 © 1997-2003 Fabio HERNANDEZ
- 9. Nature d'une Classe (suite)
Implémentation
vue interne d'une classe
comprend les secrets (détails internes) de son comportement
l'implémentation d'une classe est constituée de l'implémentation de
chacune des opérations définies dans son interface
réponse à la question comment
contenue dans un fichier d'implémentation (.cpp)
POO en C++: Objets et Classes 204 © 1997-2003 Fabio HERNANDEZ
- 10. Exemple: classe Point
Ecriture en C++ d'une classe (interface et implémentation)
représentant la notion d'un point en deux dimensions
y
ρ
θ
O x
POO en C++: Objets et Classes 205 © 1997-2003 Fabio HERNANDEZ
- 11. Classe Point: abstraction
Quels sont les attributs d'un point qui nous intéressent?
la coordonnée x
la coordonnée y
la distance à l'origine (ρ)
l'angle par rapport à l'horizontale (θ)
Quelles sont les opérations applicables sur un point qui nous
intéressent ?
translation
rotation autour de l'origine
...
POO en C++: Objets et Classes 206 © 1997-2003 Fabio HERNANDEZ
- 12. Classe Point : interface
Définition (incomplète) de l'interface de la classe Point
Fichier Point.h
class Point { // Not yet finished !!!
public:
float getX(); // returns the x coordinate
float getY(); // returns the y coordinate
float rho(); // returns the distance to the origin
float theta(); // returns the angle to the
// horizontal axis
void translate(float horizontal, float vertical);
void rotate(float angle);
};
POO en C++: Objets et Classes 207 © 1997-2003 Fabio HERNANDEZ
- 13. Classe Point : interface (suite)
getX, getY, rho, theta, translate et rotate sont des
méthodes (services) fournies par toutes les instances de la
classe Point
getX, getY, rho et theta retournent une valeur de type
float
translate et rotate ne retournent rien
translate et rotate ont besoin d'information supplémentaire
pour accomplir leur mission
un déplacement horizontal et vertical, dans le cas de translate
un angle, dans le cas de rotate
Y a-t-il des similarités avec la déclaration des fonctions,
étudiée précédemment?
Le mot clé public sert à contrôler l'accès aux méthodes de la
classe. Plus d'informations à ce propos plus tard.
POO en C++: Objets et Classes 208 © 1997-2003 Fabio HERNANDEZ
- 14. Classe Point : utilisation
Comment utiliser les services offerts par les objets de la classe
Point?
il faut définir un objet de cette classe et ensuite...
lui envoyer un message indiquant le service que l'on demande
La définition de l'objet est faite de la même façon que la
définition des objets des types primitifs
int count;
Point p;
Pour envoyer le message indiquant le service demandé on utilise
la notation
service demandé
objet destinataire p.rotate(45.0);
du message
argument(s) du service
POO en C++: Objets et Classes 209 © 1997-2003 Fabio HERNANDEZ
- 15. Classe Point : utilisation (suite)
Utilisation d'objets de la classe Point (fichier main.cpp)
#include <iostream>
inclusion du fichier
#include "Point.h" qui contient
l'interface
void main()
de la classe
{
// Instantiate a Point object
Point p;
// Show its coordinates
cout << "p is ("
<< p.getX() << ',' << p.getY()
<< ')' << endl;
POO en C++: Objets et Classes 210 © 1997-2003 Fabio HERNANDEZ
- 16. Classe Point : utilisation (suite)
// Show its angle
cout << "The angle theta of p is: " << p.theta()
<< endl;
// Let's translate p
p.translate(10.0, 20.0);
// Show again its coordinates, after the translation
cout << "p is now (" << p.getX() << ',' << p.getY()
<< ')'<< endl;
} // main
POO en C++: Objets et Classes 211 © 1997-2003 Fabio HERNANDEZ
- 17. Classe Point : utilisation (suite)
Lors de l'exécution de ce programme, il devrait s'afficher à
l'écran
p is (0.0,0.0)
The angle theta of p is: 0.0
p is now (10.0,20.0)
POO en C++: Objets et Classes 212 © 1997-2003 Fabio HERNANDEZ
- 18. Classe Point : utilisation (suite)
La définition de pointeurs aux objets d'une classe se fait de la
même façon que celle des pointeurs aux objets des types
primitifs
int* anIntPointer;
Point* aPointPointer;
L'allocation de mémoire se fait à l'aide de l'opérateur new
anIntPointer = new int;
aPointPointer = new Point;
L'envoi de messages, à l'aide de l'opérateur ->
aPointPointer->translate(10.0, 20.0);
La désallocation, à l'aide de l'opérateur delete
delete aPointPointer;
POO en C++: Objets et Classes 213 © 1997-2003 Fabio HERNANDEZ
- 19. Classe Point : implémentation
Comment implémenter chacun des services spécifiés dans le
contrat (interface de la classe) ?
Tout d'abord, il faut déterminer les attributs qui constitueront
l'état d'un point, dans la perspective de notre abstraction
Nous allons représenter un point comme un couple (x,y)
Chacune des coordonnées est une valeur de type float
Les attributs représentant les coordonnées x et y s'appelleront
x_ et y_ respectivement
Le caractère souligné de x_ et y_ est une convention de style
Les attributs x_ et y_ sont appelés les données membres, par
opposition aux fonctions membres ( getX, getY, rho, theta,
translate, rotate) de la classe
POO en C++: Objets et Classes 214 © 1997-2003 Fabio HERNANDEZ
- 20. Classe Point : implémentation (suite)
class Point { // Not yet finished !!!
public:
float getX();
// returns the x coordinate
float getY();
// returns the y coordinate
float rho();
// returns the distance to the origin
float theta();
// returns the angle to the
// horizontal axis
void translate(float horizontal, float vertical);
void rotate(float angle);
float x_; // x coordinate
float y_; // y coordinate
};
POO en C++: Objets et Classes 215 © 1997-2003 Fabio HERNANDEZ
- 21. Classe Point : implémentation (suite)
Notation quasi UML (Unified Modeling Language)
http://www.rational.com/uml
Point Nom de la classe
Nom de la classe
x_: float
y_: float Attributs
Attributs
getX: float
getY: float
rho: float
theta: float Opérations
Opérations
translate: void
rotate: void
POO en C++: Objets et Classes 216 © 1997-2003 Fabio HERNANDEZ
- 22. Classe Point : implémentation (suite)
En temps d'exécution
// Create a point object
Point p1;
p1: Point
x_ = 0.0
y_ = 0.0
// Create another point object
Point p2; Deux instances
Deux instances
différentes de la même
différentes de la même
p1: Point p2: Point classe Point,,avec les
classe Point avec les
x_ = 0.0 x_ = 0.0 mêmes valeurs dans leurs
mêmes valeurs dans leurs
y_ = 0.0 y_ = 0.0 attributs
attributs
POO en C++: Objets et Classes 217 © 1997-2003 Fabio HERNANDEZ
- 23. Classe Point : implémentation (suite)
En temps d'exécution (suite)
// Translate p1
p1.translate(34.5, 18.8);
p1: Point p2: Point
x_ = 34.5 x_ = 0.0
y_ = 18.8 y_ = 0.0
// Now translate p2
p2.translate(-10.0, 20.0);
p1: Point p2: Point
x_ = 34.5 x_ = -10.0
y_ = 18.8 y_ = 20.0
POO en C++: Objets et Classes 218 © 1997-2003 Fabio HERNANDEZ
- 24. Classe Point : implémentation (suite)
Et si on utilise des pointeurs
// Create a point pointer
Point* p1 = new Point;
p1
:Point
x_ = 0.0
y_ = 0.0
// Create another pointer
Point* p2 = p1; Une seule instance
Une seule instance
p1 p2 de la même classe
de la même classe
:Point Point,,référencée
Point référencée
x_ = 0.0 par deux pointeurs
par deux pointeurs
y_ = 0.0 différents
différents
POO en C++: Objets et Classes 219 © 1997-2003 Fabio HERNANDEZ
- 25. Classe Point : implémentation (suite)
Et si on utilise des pointeurs (suite)
// Translate the point pointed to by p1
p1->translate(34.5, 18.8);
p1 p2
:Point
x_ = 34.5
y_ = 18.8
// Now translate the point pointed to by p2
p2->translate(-10.0, 20.0);
p1 p2
:Point
x_ = 24.5
y_ = 38.8
POO en C++: Objets et Classes 220 © 1997-2003 Fabio HERNANDEZ
- 26. Classe Point : implémentation (suite)
Nous pouvons maintenant implémenter chacune des fonctions
membres de la classe
L'implémentation de ces fonctions sera écrite dans un fichier
de type .cpp
Nous créons ainsi le fichier Point.cpp
POO en C++: Objets et Classes 221 © 1997-2003 Fabio HERNANDEZ
- 27. Fichier Point.cpp
///////////////////////////////////////////////////////
// File: Point.cpp
// Description: implementation of the Point class
///////////////////////////////////////////////////////
#include "Point.h"
#include <math.h> // we need sin(), cos(), sqrt()
float Point::getX()
{
return x_;
}
float Point::getY()
{
return y_;
}
POO en C++: Objets et Classes 222 © 1997-2003 Fabio HERNANDEZ
- 28. Fichier Point.cpp (suite)
float Point::rho()
{
return sqrt(x_*x_ + y_*y_);
}
float Point::theta()
{
return atan2(y_, x_);
}
POO en C++: Objets et Classes 223 © 1997-2003 Fabio HERNANDEZ
- 29. Fichier Point.cpp (suite)
void Point::translate(float horizontal, float vertical)
{
x_ += horizontal;
y_ += vertical;
}
void Point::rotate(float angle) Une fonction
Une fonction
{ membre peut en
membre peut en
float currentRho = rho(); appeler d'autres
appeler d'autres
float newTheta = theta() + angle; de la même
de la même
x_ = currentRho * cos(newTheta); classe
classe
y_ = currentRho * sin(newTheta);
}
POO en C++: Objets et Classes 224 © 1997-2003 Fabio HERNANDEZ
- 30. Contrôle d'accès
Le mot clé public dans l'interface de la classe Point établit
pour un service (fonction membre), qu'il est utilisable par n'importe quel
objet client
pour un attribut (donnée membre), qu'il est accessible (y compris pour le
modifier) depuis n'importe quel autre objet
En particulier, nous pourrions faire
// Instantiate a Point object
Point p;
// WARNING: its x attribute can be modified!!!!
p.x_ = 47.0;
POO en C++: Objets et Classes 225 © 1997-2003 Fabio HERNANDEZ
- 31. Contrôle d'accès (suite)
L'accès public n'est pas souhaitable principalement pour les
attributs de la classe
Les données membres d'une classe font partie des secrets de
l'implémentation et ne devraient donc pas être accessibles en
dehors de l'objet
Nous devrions pouvoir encapsuler ces attributs de façon à ce
que les clients de la classe ne puissent pas y accéder
directement
C++ offre plusieurs niveaux pour contrôler l'accès aux
fonctions/données membres
public
protégé
privé
POO en C++: Objets et Classes 226 © 1997-2003 Fabio HERNANDEZ
- 32. Contrôle d'accès (suite)
Accès public
Mot clé public
Les fonctions/données membres sont accessibles par tous les objets
Accès protégé
Mot clé protected
Etroitement lié avec les mécanismes d'héritage
L'accès est limité aux classes de la hiérarchie
Plus de détails quand nous étudierons l'héritage
Accès privé
Mot clé private
Les fonctions/données membres sont accessibles uniquement par les
fonctions qui implémentent les services offerts par la classe, et pas de
l'extérieur
POO en C++: Objets et Classes 227 © 1997-2003 Fabio HERNANDEZ
- 33. Contrôle d'accès (suite)
Il est nécessaire de modifier l'interface de la classe Point
class Point { // Not yet finished !!!
public:
float getX(); // returns the x coordinate
float getY(); // returns the y coordinate
float rho(); // returns the distance to the origin
float theta(); // returns the angle to the
// horizontal axis
void translate(float horizontal, float vertical);
void rotate(float angle);
private:
float x_; // x coordinate
float y_; // y coordinate
};
POO en C++: Objets et Classes 228 © 1997-2003 Fabio HERNANDEZ
- 34. Contrôle d'accès (suite)
Il est maintenant impossible d'accéder de l'extérieur aux
attributs de la classe Point directement
// Instantiate a Point object
Point p;
// Let's try to access the x_ attribute
cout << "p.x_ = "
<< p.x_ << endl; // Compilation ERROR:
// the x_ attribute is
// private!!!
POO en C++: Objets et Classes 229 © 1997-2003 Fabio HERNANDEZ
- 35. Contrôle d'accès (suite)
Notez qu'il n'est pas nécessaire de modifier l'implémentation
des fonctions membres de la classe (rotate, translate,
theta, rho, getX et getY)
Toute fonction membre d'une classe peut accéder à tous les
attributs et à toute autre fonction membre, y compris ceux
privés, de la même classe
C'est un mécanisme très puissant de la technologie objet. Il
permet de
séparer complètement interface et implémentation
cacher les détails (secrets) de l'implémentation aux clients
(encapsulation)
Résultat: les modifications faites à l'implémentation de la
classe n'ont aucun impact chez les clients
POO en C++: Objets et Classes 230 © 1997-2003 Fabio HERNANDEZ
- 36. Contrôle d'accès (suite)
tr
te an
a sla
rot t e Encapsulation ::pour
Encapsulation pour
x_ accéder aux données
accéder aux données
membres de la classe, il
membres de la classe, il
y_ faut utiliser les services
faut utiliser les services
get
o
fournis par la classe
rh
fournis par la classe
X
get
Y h e ta
t
Classe Point
POO en C++: Objets et Classes 231 © 1997-2003 Fabio HERNANDEZ
- 37. Fonctions Membres
On peut différencier les fonctions membres d'une classe par
rapport à leur mission
gestion (comparaison, création/initialisation, destruction, copie, ...)
modification de l'état
consultation de l'état (attributs) de l'objet
fonctions d'aide
itération, pour les classes d'objets qui sont des conteneurs d'autres
objets
Dans notre implémentation de la classe Point
getX(), getY(), rho() et theta() servent à consulter l'état de
l'objet
translate() et rotate() modifient l'état de l'objet
il n'y a pas (encore) des fonctions membres de gestion ni d'aide
POO en C++: Objets et Classes 232 © 1997-2003 Fabio HERNANDEZ
- 38. Fonctions Membres (suite)
Si le contraire n'est pas explicitement spécifié, en C++ les
fonctions membres sont des modificateurs potentiels de l'état
de l'objet
En conséquence, il est impossible de demander un service à un
objet défini constant, si la fonction membre qui implémente le
service ne l'est pas
// Define a constant point
const Point origin;
// Retrieve the theta angle
float angle = origin.theta(); // Compilation ERROR:
// 'origin' is constant
// and Point::theta()
// is not
POO en C++: Objets et Classes 233 © 1997-2003 Fabio HERNANDEZ
- 39. Fonctions Membres (suite)
d'après l'interface de la classe, la fonction membre theta() est un
modificateur potentiel de l'état de l'objet origin
ceci est incompatible avec le fait que origin est constant
Il faut modifier légèrement l'interface de la classe Point
pour informer le compilateur que Point::theta() ne modifie
pas l'état des objets de sa classe
Il suffit d'ajouter le mot clé const à la déclaration de la
fonction membre
POO en C++: Objets et Classes 234 © 1997-2003 Fabio HERNANDEZ
- 40. Fonctions Membres (suite)
Modification de l'interface de la classe Point (fichier
Point.h)
class Point { // Not yet finished !!!
public:
// Modifiers
void translate(float horizontal, float vertical);
void rotate(float angle);
// Selectors
float getX() const; // x coordinate
float getY() const; // y coordinate
POO en C++: Objets et Classes 235 © 1997-2003 Fabio HERNANDEZ
- 41. Fonctions Membres (suite)
float rho() const; // distance to the origin
float theta() const; // angle to the
// horizontal axis
private:
// Data members
float x_; // Cartesian coordinates
float y_;
};
POO en C++: Objets et Classes 236 © 1997-2003 Fabio HERNANDEZ
- 42. Fonctions Membres (suite)
Modification de l'implémentation de la classe Point (fichier
Point.cpp), pour refléter les changements dans l'interface
///////////////////////////////////////////////////////
// File: Point.cpp
// Description: implementation of the Point class
///////////////////////////////////////////////////////
#include "Point.h"
#include <math.h> // we need sin(), cos(), sqrt()
POO en C++: Objets et Classes 237 © 1997-2003 Fabio HERNANDEZ
- 43. Fonctions Membres (suite)
///////////////////////////////////////////////////////
// Modifiers
void Point::translate(float horizontal, float vertical)
{
x_ += horizontal;
y_ += vertical;
}
void Point::rotate(float angle)
{
float currentRho = rho();
float newTheta = theta() + angle;
x_ = currentRho * cos(newTheta);
y_ = currentRho * sin(newTheta);
}
POO en C++: Objets et Classes 238 © 1997-2003 Fabio HERNANDEZ
- 44. Fonctions Membres (suite)
///////////////////////////////////////////////////////
// Selectors
float Point::getX() const
{
return x_;
}
float Point::getY() const
{
return y_;
}
POO en C++: Objets et Classes 239 © 1997-2003 Fabio HERNANDEZ
- 45. Fonctions Membres (suite)
float Point::rho() const
{
return sqrt(x_*x_ + y_*y_);
}
float Point::theta() const
{
return atan2(y_, x_);
}
POO en C++: Objets et Classes 240 © 1997-2003 Fabio HERNANDEZ
- 46. Fonctions Membres d'Initialisation
Comme pour les types primitifs, lors de la définition d'un objet
le compilateur doit
réserver une quantité de mémoire suffisante pour stocker l'objet
donner une valeur initiale à l'objet
Initialiser un objet composé de plusieurs données membres
(comme un objet de la classe Point) se traduit par donner une
valeur initiale à chacune d'elles
Le compilateur fournit une fonction d'initialisation par défaut
pour chaque classe
Appelée implicitement lors
de la définition d'un objet
Point p;
POO en C++: Objets et Classes 241 © 1997-2003 Fabio HERNANDEZ
- 47. Fonctions Membres d'Initialisation (suite)
de l'allocation d'un objet via l'opérateur new
Point* pointPointer = new Point;
Dans notre exemple de classe Point, cette fonction donne une
valeur initiale aux atributs x_ et y_ (probablement zéro)
C++ offre au programmeur la possibilité de définir sa propre
méthode d'initialisation
Cette méthode d'initialisation est appelée le constructeur
Un constructeur est une fonction membre comme les autres,
avec deux caractéristiques particulières
il porte le même nom que la classe
il n'a pas un type de valeur de retour, même pas void
Ajoutons le constructeur à la classe Point
POO en C++: Objets et Classes 242 © 1997-2003 Fabio HERNANDEZ
- 48. Fonctions Membres d'Initialisation (suite)
class Point {
public:
// Constructor
Point();
// Modifiers
...
// Selectors
...
private:
// Data members
...
};
POO en C++: Objets et Classes 243 © 1997-2003 Fabio HERNANDEZ
- 49. Fonctions Membres d'Initialisation (suite)
Le fichier Point.cpp doit être modifié pour ajouter
l'implémentation du constructeur
///////////////////////////////////////////////////////
// Constructor
Point::Point()
{
x_ = 0.0;
y_ = 0.0;
}
POO en C++: Objets et Classes 244 © 1997-2003 Fabio HERNANDEZ
- 50. Fonctions Membres d'Initialisation (suite)
C++ permet de définir plusieurs constructeurs différents pour
la même classe
Leur signatures doivent être différentes
Nous pourrions ajouter à notre classe Point un constructeur
afin de pouvoir créer un objet et spécifier les valeurs initiales
des coordonées
l'implémentation de la classe Point ne nous permet pas de faire cela
directement, mais en deux étapes
// Create the point object
Point p; // p is (0.0, 0.0)
// Translate it
p.translate(45.0, 80.0);
POO en C++: Objets et Classes 245 © 1997-2003 Fabio HERNANDEZ
- 51. Fonctions Membres d'Initialisation (suite)
class Point {
public:
// Constructors
Point();
Point(float initialX, float initialY);
// Modifiers
...
// Selectors
...
private:
// Data members
...
};
POO en C++: Objets et Classes 246 © 1997-2003 Fabio HERNANDEZ
- 52. Fonctions Membres d'Initialisation (suite)
La classe Point offre maintenant deux possibilités de création
d'objets
// Create a point at (45.0, 80.0)
Point p(45.0, 80.0); // calls Point::Point(float,float)
// Create a point at (0.0, 0.0)
Point origin; // calls Point::Point()
// Create a point at (5.0, 10.0) in the heap
Point* pointPointer = new Point(5.0, 10.0);
POO en C++: Objets et Classes 247 © 1997-2003 Fabio HERNANDEZ
- 53. Fonctions Membres d'Initialisation (suite)
Le fichier Point.cpp contiendra l'implémentation du nouveau
constructeur
///////////////////////////////////////////////////////
// Constructors
Point::Point() // Default constructor
{
x_ = 0.0;
y_ = 0.0;
}
Point::Point(float initialX, float initialY)
{
x_ = initialX;
y_ = initialY;
}
POO en C++: Objets et Classes 248 © 1997-2003 Fabio HERNANDEZ
- 54. Fonction Membre de Destruction
La fonction membre de destruction est appelée quand
un objet créé dans la pile d'exécution sort du contexte (fin de bloc ou
fin de fonction par exemple)
un objet créé dans le tas est explicitement détruit avec l'opérateur
delete
Comme pour les constructeurs, le compilateur fournit un
destructeur par défaut
Le destructeur est utile pour libérer les ressources acquis lors
de la création/modification de l'objet
libération de mémoire
fermeture des fichiers
libération de verrous
...
POO en C++: Objets et Classes 249 © 1997-2003 Fabio HERNANDEZ
- 55. Fonction Membre de Destruction (suite)
Une classe ne peut avoir qu'un seul destructeur
Le destructeur porte le nom de la classe précédé du caractère
~ (tilda)
Comme pour les constructeurs, le destructeur n'a pas de type
de valeur retour
A la différence des constructeurs, le destructeur n'accepte
pas de paramètres
POO en C++: Objets et Classes 250 © 1997-2003 Fabio HERNANDEZ
- 56. Fonction Membre de Destruction (suite)
class Point {
public:
// Constructors/Destructor
Point();
Point(float initialX, float initialY);
~Point();
// Modifiers
...
// Selectors
...
private:
// Data members
...
};
POO en C++: Objets et Classes 251 © 1997-2003 Fabio HERNANDEZ
- 57. Fonction Membre de Destruction (suite)
Le fichier Point.cpp contiendra l'implémentation du
destructeur
///////////////////////////////////////////////////////
// Destructor
Point::~Point()
{
// Nothing to be done
}
POO en C++: Objets et Classes 252 © 1997-2003 Fabio HERNANDEZ
- 58. Organisation des Fichiers Source
Point.h Point.cpp
#include <math.h>
#include <math.h>
#if !defined(POINT_H)
#if !defined(POINT_H) #include "Point.h"
#include "Point.h"
#define POINT_H
#define POINT_H
Point::Point()
Point::Point()
{{
class Point {
class Point { x_ = 0.0;
x_ = 0.0;
public:
public: y_ = 0.0;
y_ = 0.0;
Point(); }}
Point();
~Point();
~Point();
…… Point::~Point()
Point::~Point()
…… {
private: {
private: }}
float x_;
float x_;
float y_;
float y_; Point::getX()
Point::getX()
}; {{
}; return x_;
return x_;
}}
#endif // POINT_H
#endif // POINT_H ……
……
POO en C++: Objets et Classes 253 © 1997-2003 Fabio HERNANDEZ
- 59. Exercices
Ajouter une fonction membre pour comparer deux objets de la
classe Point et déterminer s'ils sont identiques
Ajouter une fonction membre pour copier un objet de la classe
Point dans un autre
Ajouter un troisième constructeur (appelé constructeur de
copie) pour construire un objet de la classe Point à partir d'un
objet de la classe Point passé comme argument
Ajouter une fonction membre pour modifier les valeurs des
coordonnées (x et/ou y) d'un objet de la classe Point
Quelles modifications faut-il faire si l'on veut représenter un
Point en coordonnées polaires et non pas cartésiennes et ce
sans impacter les clients de la classe?
POO en C++: Objets et Classes 254 © 1997-2003 Fabio HERNANDEZ
- 60. Résumé
La classe est un moule pour construire des entités qui partagent
structure et comportement
L'interface et l'implémentation d'une classe sont clairement
identifiées
L'interface d'une classe est un contrat vis-à-vis des clients
L'objet est la structure dynamique d'un programme
Les objets collaborent (échangent des messages) pour résoudre
le problème en question
Un objet est constitué d'attributs (structure) et de fonctions
membres (comportement)
L'accès aux données et aux fonctions membres peut être
contrôlé et vérifié en temps de compilation
POO en C++: Objets et Classes 255 © 1997-2003 Fabio HERNANDEZ