Partie 8: Objets et Classes — Programmation orientée objet en C++

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é


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, ...)


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


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


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


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)


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)


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


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


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);
};


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.

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

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;


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



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)



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;


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

Classe Point : implémentation (suite)

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

float x_; // x coordinate
float y_; // y coordinate
};



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



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



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



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


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



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


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_;
}


Fichier Point.cpp (suite)
float Point::rho()
{
return sqrt(x_*x_ + y_*y_);
}

float Point::theta()
{
return atan2(y_, x_);
}


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);
}


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

Point p;

// WARNING: its x attribute can be modified!!!!
p.x_ = 47.0;


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é


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



Il est nécessaire de modifier l'interface de la classe Point
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
private:
float x_; // x coordinate
float y_; // y coordinate
};



Il est maintenant impossible d'accéder de l'extérieur aux
attributs de la classe Point directement

Point p;

// Let's try to access the x_ attribute
cout << "p.x_ = "
<< p.x_ << endl; // Compilation ERROR:
// the x_ attribute is
// private!!!



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



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

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


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


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



Modification de l'interface de la classe Point (fichier
Point.h)
public:

// Modifiers

// Selectors
float getX() const; // x coordinate
float getY() const; // y coordinate



float rho() const; // distance to the origin
float theta() const; // angle to the
// horizontal axis

private:

// Data members
float x_; // Cartesian coordinates
float y_;
};



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


///////////////////////////////////////////////////////
// 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);
}


///////////////////////////////////////////////////////
// Selectors

float Point::getX() const
{
return x_;
}

float Point::getY() const
{
return y_;
}



float Point::rho() const
{
return sqrt(x_*x_ + y_*y_);
}
float Point::theta() const
{
return atan2(y_, x_);
}


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;


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


class Point {
public:
// Constructor
Point();

// Modifiers
...

// Selectors
...

private:
// Data members
...
};


Le fichier Point.cpp doit être modifié pour ajouter
l'implémentation du constructeur

///////////////////////////////////////////////////////
// Constructor

Point::Point()
{
x_ = 0.0;
y_ = 0.0;
}



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


class Point {
public:
// Constructors
Point();
Point(float initialX, float initialY);

// Modifiers
...

// Selectors
...
private:
// Data members
...
};


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



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


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


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


class Point {
public:
// Constructors/Destructor
Point();
Point(float initialX, float initialY);
~Point();

// Modifiers
...
// Selectors
...
private:
// Data members
...
};


Le fichier Point.cpp contiendra l'implémentation du
destructeur

///////////////////////////////////////////////////////
// Destructor
Point::~Point()
{
// Nothing to be done
}


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


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?


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

Partie 8: Objets et Classes — Programmation orientée objet en C++

Contenu connexe

Tendances (20)

En vedette (11)

Similaire à Partie 8: Objets et Classes — Programmation orientée objet en C++ (20)

Partie 8: Objets et Classes — Programmation orientée objet en C++