Vous êtes sur la page 1sur 60

Programmation Orientée Objet en C++

8ème Partie: Objets et Classes

Fabio Hernandez
Fabio.Hernandez@in2p3.fr
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


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


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


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


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


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


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


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


Exemple: classe Point

} Ecriture en C++ d'une classe (interface et implémentation)


représentant la notion d'un point en deux dimensions

O x

POO en C++: Objets et Classes 205 © 1997-2003 Fabio HERNANDEZ


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


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


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
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
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


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


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


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


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
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


Classe Point : implémentation (suite)

} Notation quasi UML (Unified Modeling Language)


„ http://www.rational.com/uml

Point Nom
Nomde
delalaclasse
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


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
Deuxinstances
instances
différentes
différentesdedelalamême
même
p1: Point p2: Point classe Point,,avec
classePoint avecles
les
x_ = 0.0 x_ = 0.0 mêmes
mêmesvaleurs
valeursdans
dansleurs
leurs
y_ = 0.0 y_ = 0.0 attributs
attributs

POO en C++: Objets et Classes 217 © 1997-2003 Fabio HERNANDEZ


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


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
Uneseule
seuleinstance
instance
p1 p2 de
delalamême
mêmeclasse
classe
:Point Point,,référencée
Point référencée
x_ = 0.0 par
pardeux
deuxpointeurs
pointeurs
y_ = 0.0 différents
différents
POO en C++: Objets et Classes 219 © 1997-2003 Fabio HERNANDEZ
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


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


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


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


Fichier Point.cpp (suite)
void Point::translate(float horizontal, float vertical)
{
x_ += horizontal;
y_ += vertical;
}

void Point::rotate(float angle) Une


Unefonction
fonction
{ membre
membrepeutpeuten
en
float currentRho = rho(); appeler
appelerd'autres
d'autres
float newTheta = theta() + angle; de
delalamême
même
x_ = currentRho * cos(newTheta); classe
classe
y_ = currentRho * sin(newTheta);
}

POO en C++: Objets et Classes 224 © 1997-2003 Fabio HERNANDEZ


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


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
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


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


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


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


Contrôle d'accès (suite)

tr
te an
t a sla
ro t e Encapsulation
Encapsulation::pourpour
x_ accéder
accéderauxauxdonnées
données
membres
membresde delalaclasse,
classe,ilil
y_ faut
faututiliser
utiliserles
lesservices
services
get

o
fournis
fournispar
parlalaclasse
rh
classe
X

get ta
Y h e
t

Classe Point
POO en C++: Objets et Classes 231 © 1997-2003 Fabio HERNANDEZ
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


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


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


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


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


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


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


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


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


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


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


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
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


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


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
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


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


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


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


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
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


Organisation des Fichiers Source

Point.h Point.cpp
#include
#include <math.h>
<math.h>
#if
#if !defined(POINT_H)
!defined(POINT_H) #include "Point.h"
#include "Point.h"
#define
#define POINT_H
POINT_H
Point::Point()
Point::Point()
{{
class
class Point
Point {{ x_
x_ == 0.0;
0.0;
public:
public: y_ = 0.0;
y_ = 0.0;
Point(); }}
Point();
~Point();
~Point();
…… Point::~Point()
Point::~Point()
…… {{
private:
private: }}
float
float x_;
x_;
float
float y_;
y_; Point::getX()
Point::getX()
}; {{
}; return
return x_;
x_;
}}
#endif
#endif //
// POINT_H
POINT_H ……
……

POO en C++: Objets et Classes 253 © 1997-2003 Fabio HERNANDEZ


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


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