C++ : classes

Introduction aux Langages Orients Objets

Quest-ce quun objet ?
Proprits d'un objet
Notion dhritage et de polymorphisme

Les classes en C++

Interface de classe
Implantation
Constructeur / destructeur
Hritage / polymorphisme

Langage Orient Objet : quest-ce quun objet ?

Un objet est une entit informatique comprenant :

des donnes membres (ou champs ou attributs ou variables dinstances)

des fonctions membres (ou mthodes ou routines)
On appelle encapsulation le regroupement des variables et des fonctions au sein d'une mme
entit.

Donnes membres
Fonctions membres
Ex : un objet vecteur est compos de trois rels et doprations telles que la translation, la norme, le
produit scalaire

L'accs aux donnes et mthodes peut tre rglement :

.

Vision interne

Partie prive
Partie publique

Vision externe

Objet : exemples (notation UML)

Vision
interne

Vision
externe

DeuxRoues
m_tailleRoues
m_nbVitesses
m_couleur
m_poids
Acclrer()
Freiner()
ChangerVitesse()
GetCouleur()
GetPoids()

Nom de la classe
Donnes membres
ou attributs

Fonctions membres
ou mthodes

CompteBancaire
m_numro
m_solde
m_propritaire
Crditer()
Dbiter()
Fermer()
Numro()
Solde()
Propritaire()

Vision
interne

Vision
externe

Proprits dun objet

Un objet possde un tat :

Ltat correspond la valeur de ses attributs un instant donn. Il peut varier au cours du
temps.

Un objet est dcrit par une classe :

Une classe est un prototype qui dfinit des attributs et des mthodes communes tous les
objets d'une certaine nature. Cest donc un modle utilis pour crer plusieurs objets
prsentant des caractristiques communes.

Un objet possde une identit :

Les objets peuvent tre distingus grce leurs existences inhrentes et non grce la
description des proprits qu'ils peuvent avoir.
Deux objets peuvent tre distincts mme si tous leurs attributs ont des valeurs identiques.

Ne pas confondre instance d'objet et classe d'objets

Une instance de classe fait rfrence une chose prcise
Une classe dsigne un groupe de choses similaires
Ex : Le vlo de mon voisin et le mien sont deux instances de la classe vlo, mme sils sont
strictement identiques

Notion dhritage

L'hritage est un principe propre la POO qui permet de crer une nouvelle classe
partir d'une classe existante. La classe nouvellement cre, dite classe drive,
contient les attributs et les mthodes de la classe dont elle drive, auxquelles
sajoutent de nouveaux attributs et de nouvelles mthodes propres la classe drive.

Lhritage permet donc de dfinir une hirarchie de classes :

La classe de base est une classe gnrique.

Les classes drives sont de plus en plus spcialises

classe de base ou classe mre

ou classe parente

Deux roues

Sans moteur

Vlo

Patinette

A moteur

Moto

Scooter

classes drives
ou classes filles

Mobylette

Notion de polymorphisme
Une classe drive peut fournir une nouvelle dfinition dune mthode d'une classe parent car elle peut avoir
besoin de ragir diffremment l'appel de cette mthode. Cette redfinition substituera une mthode une autre :
cest la spcialisation.
La notion de polymorphisme signifie que, la mme opration pouvant se comporter diffremment sur
diffrentes classes de la hirarchie, il est possible d'appeler la mthode d'un objet sans se soucier de son type
intrinsque. Ceci permet de faire abstraction des dtails des classes spcialises d'une famille d'objet, en les
masquant par une interface commune (qui est la classe de base).

DeuxRoues
m_tailleRoues
m_couleur
m_poids
m_nbVitesses
virtual Acclrer()
virtual Freiner()
virtual ChangerVitesse()
GetCouleur()
GetPoids()

Velo
m_typePedale
GetTypePedale()
virtual Acclrer()
virtual Freiner()
virtual ChangerVitesse()

Moto
m_moteur
m_boiteVitesse
FairePlein()
AllumerClignotant()
virtual Acclrer()
virtual Freiner()
virtual ChangerVitesse()

La fonction Acclrer() nest pas la

mme pour un Velo et une Moto. La
redfinition de cette fonction dans
chacune des sous-classes entranera un
comportement diffrent suivant que le
DeuxRoues est un Velo ou une Moto.

Programmation oriente objet vs

programmation squentielle

Avantages :
Programmes plus faciles maintenir
Si on dcide de modifier la structure des donnes dans un programme squentiel,
presque tout le code est rcrire

Programmation plus claire : les fonctions sont rattaches un type de donnes

Modularit accrue -> possibilit de r-utiliser le code

Inconvnients :
Le programme rsultant peut tre moins efficace (en termes de taille mmoire et
de rapidit)

Classe : interface
Cest la description de la structure interne de la classe

class Ellipse
{

protected :
float m_cX, m_cY;
float m_a, m_b;

Vision
interne

public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();

Vision
externe

Visibilit des membres :

public : membres accessibles tous
private : membres accessibles
partir de la classe ; accs impossible
par lextrieur

protected : membres accessibles

partir de la classe et des classes
drives ; accs impossible par
lextrieur

};
NB : dans cet exemple, on a choisi de reprsenter l'ellipse en interne la classe par les coordonnes de
son centre (cX, cY), par son grand axe a et par son petit axe b.

Classe : implantation
Cest la dfinition des fonctions associes
Interface de la classe Ellipse
class Ellipse
{
protected :
float m_cX, m_cY;
float m_a, m_b;
public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();
};

Oprateur
de porte

void Ellipse::deplace(float dx, float dy)

{
m_cX += dx;
m_cY += dy;
}
void Ellipse ::zoom(float z)
{
m_a *= z;
m_b *= z;
}
float Ellipse ::surface()
{
return 3.14 * m_a * m_b / 4.;
}

Classe : instanciation
Interface de la classe Ellipse
class Ellipse
{
protected :
float m_cX, m_cY;
float m_r;
public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();
};
Implantation de la classe Ellipse
void Ellipse::deplace(float dx, float dy)
{
m_cX += dx;
m_cY += dy;
}
void Ellipse::zoom(float z)
{
m_a *= z;
m_b *= z;
}
float Ellipse::surface()
{
return 3.14 * m_a * m_b / 4.;
}

Instancier une classe permet de crer un objet

(analogue une dclaration de variable)

int main()
{
Ellipse e;
Accs aux
membres
par le "."

Instanciation statique de
lobjet e, e tant une
variable de type Ellipse

e.deplace(50, 0);
float s = e.surface();
e.zoom(1.5);
e.m_cX = 30;
e. deplace(20);
}

// Impossible
// Impossible

Organisation (usuelle) des fichiers

Par convention, l'extension d'un fichier contenant du code C est .cpp, .c++ , .cc , .cxx ou .C
L'extension d'un fichier de dclarations, appel header, est .h
Par convention, on cre un fichier .cpp et un .h par classe, chaque fichier ayant le nom de la classe en minuscule.
ellipse.h
class Ellipse
{
protected :
float m_cX, m_cY;
float m_a, m_b;
public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();
};

ellipse.cpp

main.cpp

#include ellipse.h

#include "ellipse.h"

void Ellipse::deplace(float dx, float dy)

{
m_cX += dx;
m_cY += dy;
}
void Ellipse ::zoom(float z)
{
m_a *= z;
m_b *= z;
}
float Ellipse :: surface()
{
return 3.14 * m_a * m_b / 4.;
}

int main()
{
Ellipse e;
e.deplace(50, 0);
float s = e.surface();
e.zoom(1.5);
return 0;
}

Par convention, les noms de classe commencent par une majuscule, les donnes membres par _ ou m_,
les fonctions membres par une minuscule.

Constructeurs de classe

Le constructeur est une fonction membre qui sert initialiser les donnes membres de
lobjet
Systmatiquement appel quand un objet est instanci.
Na pas de type de retour
Porte le nom de lobjet

Une mme classe peut avoir plusieurs constructeurs

Constructeurs particuliers :
constructeur par dfaut
Ne contient aucun argument
Automatiquement gnr si aucun constructeur nest dfini
A dfinir explicitement dans le cas contraire

constructeur de copie
Contient comme argument un objet du mme type
Sert crer des clones dobjets
Automatiquement gnr par le compilateur (copie membre membre) mais pas
toujours satisfaisant

Constructeurs de classe : exemple

ellipse.h

ellipse.cpp

main.cpp

class Ellipse
{
public :
Ellipse(); // Constructeur par dfaut
Ellipse(float x, float y, float a, float b);
Ellipse(const Ellipse & e);

#includeellipse.h

#include "ellipse.h"

Ellipse::Ellipse()
{
m_cX = m_ cY = 0;
m_a = m_b = 1;
}

int main()
{
Ellipse e1;
Ellipse e2(2.5, 6.5, 12, 15);
Ellipse e3(e1);
// e3 est un clone de e1
Ellipse e4 = e1;
// e4 est un clone de e1
return 0;
}

protected :
float m_cX, m_cY;
float m_a, m_b;
public :
void deplace(float dx, float dy);
void zoom(float z) ;
float surface() ;
};

Ellipse::Ellipse(float x, float y, float a, float b) :

m_ cX(x), m_ cY(y), m_a(a), m_b(b)
{
}
Ellipse::Ellipse(const Ellipse & e)
{
m_ cX = e. m_ cX;
m_ cY = e. m_ cY;
m_a = e.m_a ;
m_b = e.m_b;
}
void Ellipse::deplace(float dx, float dy)
{
m_ cX += dx; m_cY += dy;
}
etc

Destructeur de classe

Fonction membre systmatiquement appele juste avant la destruction dun objet

Porte le nom de la classe et est prcd de ~
Pas de type de retour
Pas darguments
Un seul par classe
Permet de librer les ressources

ellipse.h
class Ellipse
{
public :
Ellipse(); // Constructeur par dfaut
Ellipse (float x, float y, float a, float b);
Ellipse(const Ellipse & e);
~Ellipse(); // Destructeur
protected :
float m_cX, m_cY;
float m_a, m_b;
public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();
};

ellipse.cpp

prog.cpp

#includeellipse.h

#include "ellipse.h"

Ellipse::Ellipse()
{
m_cX = m_ cY = 0;
m_a = m_b = 1;
}

int main()
{
Ellipse e;
Ellipse* pE = new Ellipse(2.5, 6.5, 12, 15);
delete pE;

// appelle le destructeur pour pE

etc
return 0;
Ellipse::~ Ellipse()
{
// Libration des ressources
}
void Ellipse::deplace(float dx, float dy)
{
m_cX += dx; m_cY += dy;
}
etc

// Le destructeur est implicitement appel pour e.

}

Hritage
Lhritage permet de spcialiser une classe en dfinissant une relation de type est une sorte de .
Un cercle est un spcialisation d'une ellipse, il en possde les proprits plus d'autres qui lui sont spcifiques.
On drive donc la classe Cercle de la classe Ellipse.

Forme

Ellipse

Cercle

Rectangle

Carre

Hritage
Lhritage permet de spcialiser une classe en dfinissant une relation de type est une sorte de .
Un cercle est un spcialisation d'une ellipse, il en possde les proprits plus d'autres qui lui sont spcifiques.
On drive donc la classe Cercle de la classe Ellipse.

ellipse.h

cercle.h

prog.cpp

class Ellipse
{
public :
Ellipse();
Ellipse (float x, float y, float a, float b);
Ellipse(const Ellipse & e);
~Ellipse();

#include ellipse.h

#include "cercle.h"

class Cercle : public Ellipse

{
public :
Cercle();
Cercle (float x, float y, float diametre);
~ Cercle();
public :
virtual void affiche();
};

int main()
{
Cercle c(5, 5, 15);
c. affiche();
return 0;
}

protected :
float m_cX, m_cY;
float m_a, m_b;
public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();
Autorise la
virtual void affiche();
redfinition de
};
la fonction dans
les classes
drives

ellipse.cpp

#include <iostream.h>
void Ellipse::affiche()
{
std::cout << "Ellipse de grand axe " << m_a;
std ::cout << " et de petitt axe " << m_b << "\n";
}

cercle.cpp
#include <iostream.h>
#include cercle.h

Le constructeur de la classe drive

appelle gnralement un des
constructeurs de la classe de base.

Cercle::Cercle() : public Ellipse()

{
}
Cercle::Cercle(float x, float y, float diametre) : public Ellipse( x, y, diametre, diametre)
{
}
void Cercle::affiche()
{
std::cout << "Cercle de rayon " << m_a / 2 << "\n";
}

Polymorphisme
Un objet hritant une mthode d'une classe parente peut ragir de faon diffrente l'appel de cette mthode.
ellipse.h

cercle.h

class Ellipse
{
public :
Ellipse();
Ellipse (float x, float y, float a, float b);
Ellipse(const Ellipse & e);
~Ellipse();

#include ellipse.h

protected :
float m_cX, m_cY;
float m_a, m_b;
public :
void deplace(float dx, float dy);
void zoom(float z);
float surface();
virtual void affiche();
};

class Cercle : public Ellipse

{
public :
Cercle();
Cercle (float x, float y, float d);
~ Cercle();
public :
virtual void affiche();
};

#include " cercle.h"

int main()
{
Ellipse e(0, 0, 8.5, 10.2);
e.deplace(-1, 1);
e.affiche();

Ellipse *p1;
p1 = new Ellipse;
p1 ->affiche();

#include cercle.h
Cercle::Cercle() : public Ellipse()
{
}

#include <iostream.h>
void Ellipse::affiche()
{
std::cout << "Ellipse de grand axe " << m_a;
std ::cout << " et de petit axe " << m_b << "\n";
}

void Cercle::affiche()
{
std::cout << "Cercle de rayon ";
std::cout << m_a / 2 << "\n";
}

La fonction deplace() nest pas

redfinie dans la classe Cercle,
appelle celle de Ellipse.
La fonction affiche() est redfinie
dans la classe Cercle, appelle celle
de Cercle.

Cercle c(-2.5, 2.5, 7,4);

c.deplace(0.5, 1.5);
c. affiche();

cercle.cpp

Cercle::Cercle(float x, float y, float d) :

public Ellipse( x, y, d, d)
{
}

ellipse.cpp

main.cpp

Ellipse *p2;
p2 = new Cercle;
p2->affiche();
return 0;
}

Appelle la fonction affiche()

de la classe Ellipse.

Si la fonction affiche() est

virtuelle et est redfinie dans la
classe Cercle, appelle celle de
Cercle bien que le pointeur soit
de type Ellipse. C'est le
mcanisme de polymorphisme
d'hritage.

Vocabulaire

Variable : associe un nom (un symbole) une valeur qui peut ventuellement varier au cours du
temps ; une variable est dun type donn, dfini une fois pour toute (type prdfini dans le langage
ou cr par le dveloppeur).
Encapsulation : regroupement des variables et des fonctions au sein d'une mme entit appele
classe .
Classe : prototype qui dfinit des attributs et des mthodes communes tous les objets d'une certaine
nature.
Interface de classe : description de la structure interne de la classe incluant une liste des donnes
membres et le prototype des fonctions membres ; dans un .h .
Implantation de classe : dfinition (code) des fonctions dclares dans linterface de classe ; dans
un .cpp .
Instanciation dun objet : permet de crer un objet dun type donn ; analogue une dclaration de
variable.
Hritage : permet de dfinir une hirarchie de classe, chaque classe fille hritant des mthodes et
des donnes de son/ses antcdent(s).
Polymorphisme : deux objets hritant une mme mthode d'une classe parente, peuvent ragir de
faon diffrente l'appel de cette mthode et, cette fin, redfinir la mthode. Il est ensuite possible
d'appeler la mthode d'un objet sans se soucier de son type intrinsque.