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

Fabio [email protected]

Programmation Orientée Objet en C++Programmation Orientée Objet en C++

8ème Partie: Objets et Classes8ème Partie: Objets et Classes

© 1997-2003 Fabio HERNANDEZ197POO en C++: Objets et Classes

Vue d'EnsembleVue d'Ensemble

Notions de base Types, variables, opérateursContrôle d'exécutionFonctionsMémoire dynamiqueQualité du logicielEvolution du modèle objet Objets et classesFonctions membresClasses génériquesHéritagePolymorphismeHéritage multipleEntrée/sortie


Table des MatièresTable des Matières

Nature d'un ObjetNature d'une ClasseExemple: une classe simple

abstractiondéfinition de l'interfaceutilisationimplémentationmodificationfonction membrescontrôle d'accèsinitialisation/destruction

Résumé


Nature d'un ObjetNature 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 duproblèmeExemple: dans une usine de fabrication d'automobiles, on peut identifier des objets tels

moteurchâssisvolantsystème électriqueprocessus 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)Nature d'un Objet (suite)

Caractéristiques d'un objetEtatComportementIdentité

Etatun attribut est une caractéristique, qualité ou trait intrinsèque qui contribue à faire unique un objetl'é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 dynamiquesdu fait d'avoir un état, un objet occupe un espace dans le mondephysique et dans la mémoire de l'ordinateurexemple: les attributs de l'objet point en deux dimensions sont les coordonnées x et y


Nature d'un Objet (suite)Nature d'un Objet (suite)

Comportementfaçon d'agir et de réagir d'un objet comme conséquence des changements d'état et des opérations effectuées sur luireprésente l'activité de l'objet vue de l'extérieursi on regarde un objet comme un serveur, son comportement est l'ensemble des services offerts par lui à ses clientsexemple: 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 luil'é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 ClasseNature d'une Classe

Les notions de classe et d ’objet sont étroitement liéesUne classe est un ensemble d'objets qui partagent une structure et un comportement communsUne classe est seulement une abstractionUn objet est une instance (entité concrète) d'une classe en temps d'exécutionOn peut voir la classe comme un moule pour la fabrication d'objetsLes objets fabriqués avec le même moule partagent structure et comportement


Nature d'une Classe (suite)Nature d'une Classe (suite)

Deux vues d'une classeinterfaceimplémentation

Interfacevue externe abstraite d'une classeliste 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 classecache la structure interne de la classe (encapsulation)réponse à la question quoicontenue dans un fichier d'entête (.h)


Nature d'une Classe (suite)Nature d'une Classe (suite)

Implémentationvue interne d'une classecomprend les secrets (détails internes) de son comportementl'implémentation d'une classe est constituée de l'implémentation de chacune des opérations définies dans son interfaceréponse à la question commentcontenue dans un fichier d'implémentation (.cpp)


Exemple: classe PointExemple: classe Point

Ecriture en C++ d'une classe (interface et implémentation) représentant la notion d'un point en deux dimensions

O x

y

ρ

θ


Classe Classe PointPoint: abstraction: abstraction

Quels sont les attributs d'un point qui nous intéressent?la coordonnée xla coordonnée yla distance à l'origine (ρ)l'angle par rapport à l'horizontale (θ)

Quelles sont les opérations applicables sur un point qui nous intéressent ?

translationrotation autour de l'origine...


Classe Classe PointPoint : interface: interface

Définition (incomplète) de l'interface de la classe PointFichier 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 Classe PointPoint : interface (suite): interface (suite)

getX, getY, rho, theta, translate et rotate sont des méthodes (services) fournies par toutes les instances de la classe PointgetX, getY, rho et theta retournent une valeur de typefloat

translate et rotate ne retournent rientranslate et rotate ont besoin d'information supplémentaire pour accomplir leur mission

un déplacement horizontal et vertical, dans le cas de translateun 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 Classe PointPoint : utilisation: 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

p.rotate(45.0);objet destinatairedu message

service demandé

argument(s) du service


Classe Classe PointPoint : utilisation (suite): utilisation (suite)

Utilisation d'objets de la classe Point (fichier main.cpp)#include <iostream>

#include "Point.h"

void main(){

// Instantiate a Point object

Point p;

// Show its coordinates

cout << "p is ("

<< p.getX() << ',' << p.getY()

<< ')' << endl;

inclusion du fichierqui contient l'interfacede la classe



// 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 lamê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 newanIntPointer = 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 deletedelete aPointPointer;


Classe Classe PointPoint : implémentation: 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 constituerontl'état d'un point, dans la perspective de notre abstractionNous 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_ respectivementLe caractère souligné de x_ et y_ est une convention de styleLes 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 Classe PointPoint : implémentation (suite): 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

x_: floaty_: float

getX: floatgetY: floatrho: floattheta: floattranslate: voidrotate: void

Nom de la classeNom de la classe

AttributsAttributs

OpérationsOpérations



En temps d'exécution// Create a point object

Point p1;

// Create another point object

Point p2;

p1: Point

x_ = 0.0y_ = 0.0

p2: Point

x_ = 0.0y_ = 0.0

p1: Point

x_ = 0.0y_ = 0.0

Deux instances différentes de la mêmeclasse Point, avec les mêmes valeurs dans leurs attributs

Deux instances différentes de la mêmeclasse Point, avec les mêmes valeurs dans leurs attributs



En temps d'exécution (suite)// Translate p1

p1.translate(34.5, 18.8);

// Now translate p2

p2.translate(-10.0, 20.0);

p1: Point

x_ = 34.5y_ = 18.8

p2: Point

x_ = 0.0y_ = 0.0

p1: Point

x_ = 34.5y_ = 18.8

p2: Point

x_ = -10.0y_ = 20.0



Et si on utilise des pointeurs// Create a point pointer

Point* p1 = new Point;

// Create another pointer

Point* p2 = p1;

:Point

x_ = 0.0y_ = 0.0

Une seule instancede la même classe Point, référencée par deux pointeurs différents

Une seule instancede la même classe Point, référencée par deux pointeurs différents

p1

:Point

x_ = 0.0y_ = 0.0

p1 p2



Et si on utilise des pointeurs (suite)// Translate the point pointed to by p1

p1->translate(34.5, 18.8);

// Now translate the point pointed to by p2

p2->translate(-10.0, 20.0);

:Point

x_ = 34.5y_ = 18.8

p1 p2

:Point

x_ = 24.5y_ = 38.8

p1 p2



Nous pouvons maintenant implémenter chacune des fonctions membres de la classeL'implémentation de ces fonctions sera écrite dans un fichier de type .cppNous créons ainsi le fichier Point.cpp


Fichier Fichier Point.Point.cppcpp

///////////////////////////////////////////////////////

// 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 Fichier Point.Point.cppcpp (suite)(suite)float Point::rho(){

return sqrt(x_*x_ + y_*y_);}

float Point::theta(){

return atan2(y_, x_);}


Fichier Fichier Point.Point.cppcpp (suite)(suite)

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

}

Une fonctionmembre peut en appeler d'autresde la même classe

Une fonctionmembre peut en appeler d'autresde la même classe


Contrôle d'accèsContrô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 clientpour 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 objectPoint p;

// WARNING: its x attribute can be modified!!!!

p.x_ = 47.0;


Contrôle d'accès (suite)Contrôle d'accès (suite)

L'accès public n'est pas souhaitable principalement pour les attributs de la classeLes 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'objetNous devrions pouvoir encapsuler ces attributs de façon à ce que les clients de la classe ne puissent pas y accéder directementC++ offre plusieurs niveaux pour contrôler l'accès aux fonctions/données membres

publicprotégéprivé



Accès publicMot clé publicLes 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éritageL'accès est limité aux classes de la hiérarchiePlus 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 Pointclass Point { // Not yet finished !!!public:

float getX(); // returns the x coordinatefloat getY(); // returns the y coordinatefloat rho(); // returns the distance to the originfloat theta(); // returns the angle to the

// horizontal axisvoid translate(float horizontal, float vertical);void rotate(float angle);

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

// Instantiate a Point objectPoint 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 classeC'est un mécanisme très puissant de la technologie objet. Il permet de

séparer complètement interface et implémentationcacher 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



translaterotate

getX

getY thetarh

o

x_ y_

Encapsulation : pour accéder aux données membres de la classe, ilfaut utiliser les servicesfournis par la classe

Encapsulation : pour accéder aux données membres de la classe, ilfaut utiliser les servicesfournis par la classe

Classe Point


On peut différencier les fonctions membres d'une classe par rapport à leur mission

gestion (comparaison, création/initialisation, destruction, copie, ...)modification de l'étatconsultation de l'état (attributs) de l'objetfonctions d'aideitération, pour les classes d'objets qui sont des conteneurs d'autres objets

Dans notre implémentation de la classe PointgetX(), getY(), rho() et theta() servent à consulter l'état de l'objettranslate() et rotate() modifient l'état de l'objetil n'y a pas (encore) des fonctions membres de gestion ni d'aide

Fonctions MembresFonctions Membres


Fonctions Membres (suite)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'objetEn 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 anglefloat 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 originceci 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 classeIl suffit d'ajouter le mot clé const à la déclaration de la fonction membre



Modification de l'interface de la classe Point (fichierPoint.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 (fichierPoint.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'InitialisationFonctions Membres d'Initialisation

Comme pour les types primitifs, lors de la définition d'un objetle compilateur doit

réserver une quantité de mémoire suffisante pour stocker l'objetdonner 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'ellesLe compilateur fournit une fonction d'initialisation par défaut pour chaque classeAppelée implicitement lors

de la définition d'un objetPoint p;


Fonctions Membres d'Initialisation (suite)Fonctions Membres d'Initialisation (suite)

de l'allocation d'un objet via l'opérateur newPoint* 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'initialisationCette méthode d'initialisation est appelée le constructeurUn constructeur est une fonction membre comme les autres, avec deux caractéristiques particulières

il porte le même nom que la classeil 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 classeLeur signatures doivent être différentesNous 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);




// Constructors

Point();

Point(float initialX, float initialY);

// Modifiers

...

// Selectors

...


};



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 DestructionFonction 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érateurdelete

Comme pour les constructeurs, le compilateur fournit un destructeur par défautLe destructeur est utile pour libérer les ressources acquis lorsde la création/modification de l'objet

libération de mémoirefermeture des fichierslibération de verrous...


Fonction Membre de Destruction (suite)Fonction Membre de Destruction (suite)

Une classe ne peut avoir qu'un seul destructeurLe 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 retourA la différence des constructeurs, le destructeur n'accepte pas de paramètres




// Constructors/Destructor

Point();

Point(float initialX, float initialY);

~Point();

// Modifiers

...

// Selectors

...


};



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

///////////////////////////////////////////////////////// Destructor

Point::~Point(){

// Nothing to be done}


Organisation des Fichiers SourceOrganisation des Fichiers Source

#if !defined(POINT_H)#define POINT_H


Point();~Point();……

private:float x_;float y_;

};

#endif // POINT_H

#if !defined(POINT_H)#define POINT_H


Point();~Point();……

private:float x_;float y_;

};

#endif // POINT_H

Point.h Point.cpp

#include <math.h>#include "Point.h"

Point::Point(){

x_ = 0.0;y_ = 0.0;

}

Point::~Point(){}

Point::getX(){

return x_;}

……

#include <math.h>#include "Point.h"

Point::Point(){

x_ = 0.0;y_ = 0.0;

}

Point::~Point(){}

Point::getX(){

return x_;}

……


ExercicesExercices

Ajouter une fonction membre pour comparer deux objets de la classe Point et déterminer s'ils sont identiquesAjouter une fonction membre pour copier un objet de la classe Point dans un autreAjouter 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 argumentAjouter une fonction membre pour modifier les valeurs des coordonnées (x et/ou y) d'un objet de la classe PointQuelles 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éRésumé

La classe est un moule pour construire des entités qui partagentstructure et comportementL'interface et l'implémentation d'une classe sont clairement identifiéesL'interface d'une classe est un contrat vis-à-vis des clientsL'objet est la structure dynamique d'un programmeLes objets collaborent (échangent des messages) pour résoudre le problème en questionUn 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

Technology

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