MODULE : POO
Enseignant : Mohamed Kharrat Année universitaire 2016/2017
1
Séance 5
C++ : classes
- Introduction aux Langages Orientés Objets
- Qu’est-ce qu’un objet ?
- Propriétés d’un objet
- Notion d’héritage et de polymorphisme
- Les classes en C++
– Interface de classe – Implantation – Constructeur / destructeur – Héritage / polymorphisme
Objet?
- Objectif? • Exemples d’objets • une fenêtre ; • un bouton ; • Une voiture • … • Beaucoup de choses peuvent être considérées comme des objets. • Concrètement, c’est quoi ? Une variable ? Une fonction ?
Différence de la programmation OO par rapport à la programmation impérative/procédurale
Programmation orientée objet vs programmation impérative
- Avantages :
- Programmes plus faciles à maintenir
Si on décide de modifier la structure des données dans un programme séquentiel, presque tout le code est à réécrire
- Programmation plus claire : les fonctions sont rattachées à un type de données
- Modularité accrue -> possibilité de réutiliser le code
Langage Orienté Objet : qu’est-ce qu’un objet ?
- Un objet est une entité informatique comprenant :
– des données membres (ou champs ou attributs ou variables d’instances) – des fonctions membres (ou méthodes ou routines)
On appelle encapsulation le regroupement des variables et des fonctions au sein d’une même entité.
Données membres
Fonctions membres
Ex : un objet vecteur est composé de trois réels et d’opérations telles que la translation, la norme, le
produit scalaire …
- L’accès aux données et méthodes peut être réglementé :
.
Vision interne Partie privée
Partie publique Vision externe
Vision interne
Vision externe
Objet : exemples (notation UML)
DeuxRoues m_tailleRoues m_nbVitesses m_couleur m_poids Accélérer() Freiner() ChangerVitesse() GetCouleur() GetPoids()
Nom de la classe
Données membres ou attributs
Fonctions membres ou méthodes
CompteBancaire m_numéro m_solde m_propriétaire Créditer() Débiter() Fermer() Numéro() Solde() Propriétaire()
Vision interne
Vision externe
Propriétés d’un objet
- Un objet possède un état :
L’état correspond à la valeur de ses attributs à un instant donné. Il peut varier au cours du temps.
- Un objet est décrit par une classe :
Une classe est un prototype qui définit des attributs et des méthodes communes à tous les objets d’une certaine nature. C’est donc un modèle utilisé pour créer plusieurs objets présentant des caractéristiques communes.
- Un objet possède une identité :
Les objets peuvent être distingués grâce à leurs existences inhérentes et non grâce à la description des propriétés qu’ils peuvent avoir. Deux objets peuvent être distincts même si tous leurs attributs ont des valeurs identiques.
Ne pas confondre instance d’objet et classe d’objets
Une instance de classe fait référence à une chose précise Une classe désigne un groupe de choses similaires Ex : Le vélo de mon voisin et le mien sont deux instances de la classe vélo, même s’ils sont strictement identiques
Classe (plan de construction)
www.
Objet (instance de la classe)
Objet (instance de
la classe)
Objet (instance de
la classe)
Notion d’héritage
- L’héritage permet de définir une hiérarchie de classes :
- La classe de base est une classe générique.
- Les classes dérivées sont de plus en plus spécialisées
Deux roues
Sans moteur
Scooter
classe de base ou classe mère ou classe parente
classes dérivées A moteur
ou classes filles
Vélo Patinette
Moto Mobylette
Héritage: Relations a-un, est-un, utilise-un
- Supposons que nous déclarions les quatre classes suivantes : Voiture, Moteur, Route et Véhicule.
- Quel genre de relation y a-t-il entre la classe Voiture et les trois autres classes ?
Notion de polymorphisme
Une classe dérivée peut fournir une nouvelle définition d’une méthode d’une classe parent car elle peut avoir besoin de réagir différemment à l’appel de cette méthode. Cette redéfinition substituera une méthode à une autre : c’est la spécialisation.
DeuxRoues m_tailleRoues m_couleur m_poids m_nbVitesses virtual Accélérer() virtual Freiner() virtual ChangerVitesse() GetCouleur() GetPoids()
Velo m_typePedale GetTypePedale() virtual Accélérer() virtual Freiner() virtual ChangerVitesse()
Moto m_moteur m_boiteVitesse FairePlein() AllumerClignotant() virtual Accélérer() virtual Freiner() virtual ChangerVitesse()
La fonction Accélérer() n’est pas la même pour un Velo et une Moto. La redéfinition de cette fonction dans chacune des sous-classes entraînera un comportement différent suivant que le DeuxRoues est un Velo ou une Moto.
Classe : interface
C’est la description de la structure interne de la classe
class Ellipse
{
Vision interne
protected :
float m_cX, m_cY; float m_a, m_b;
public :Vision externe
void deplace(float, float ); void zoom(float z); float surface();
};
NB : dans cet exemple, on a choisi de représenter l’ellipse en interne à la classe par les coordonnées de son centre (cX, cY), par son grand axe a et par son petit axe b.
Classe : implantation
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(); };
C’est la définition des fonctions associées
Opérateur de portée
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 créer un objet
(analogue à une déclaration de variable)
Accès aux membres par le « . »
Instanciation statique de
int main() {
l’objet e, e étant une variable de type Ellipse
Ellipse e;
e.deplace(50, 0); float s = e.surface(); e.zoom(1.5);
e.m_cX = 30; // Impossible e. deplace(20); // Impossible }
Organisation (usuelle) des fichiers
#include “ellipse.h”
#include « ellipse.h »
void Ellipse::deplace(float dx, float dy) {
m_cX += dx; m_cY += dy;
int main() {
Ellipse e;
}void Ellipse ::zoom(float z) {
m_a *= z;
- Par convention, on crée un fichier .cpp et un .h ayant le nom de la classe en minuscule.
ellipse.h ellipse.cpp main.cpp
class Ellipse {protected :
float m_cX, m_cY; float m_a, m_b;
e.deplace(50, 0); public :float s = e.surface();
void deplace(float dx, float dy);
e.zoom(1.5);
void zoom(float z);
m_b *= z; float surface(); }};
float Ellipse :: surface()
return 0; }
{
return 3.14 * m_a * m_b / 4.; }
Constructeurs de classe
- Le constructeur est une fonction membre qui sert à initialiser les données membres de l’objet • Systématiquement appelé quand un objet est instancié. • N’a pas de type de retour • Porte le nom de l’objet
- Une même classe peut avoir plusieurs constructeurs
- Constructeurs particuliers : • constructeur par défaut • Ne contient aucun argument • Automatiquement généré si aucun constructeur n’est défini • A définir explicitement dans le cas contraire • constructeur de copie • Contient comme argument un objet du même type • Sert à créer des clones d’objets • Automatiquement généré par le compilateur (copie membre à membre) mais pas toujours satisfaisant
class MaClasse1 { public: MaClasse1(); // ceci est le constructeur par défaut }; class MaClasse2 { public: MaClasse2( int i = 1 ); // ceci est le constructeur par défaut }; class MaClasse3 { public: MaClasse3( int i ); // ceci n’est pas le constructeur par défaut
};
La liste d’initialisation
Personnage::Personnage() {
m_vie = 100; m_mana = 100; m_nomArme = « Épée rouillée »; m_degatsArme = 10; }
Personnage::Personnage() : m_vie(100), m_mana(100), m_nomArme(« Épée rouillée »), m_degatsArme(10) { //Rien à mettre dans le corps du constructeur, tout a déjà été fait ! }
constructeur de copie
class MaClasse { public: MaClasse( const MaClasse & );
};
Y a-t-il une différence quelconque entre ces deux instructions: MaClasse x; MaClasse x();
Constructeurs de classe : exemple
ellipse.h ellipse.cpp main.cpp
class Ellipse
#include “ellipse.h”
#include « ellipse.h » {public :
Ellipse::Ellipse()
int main() Ellipse(); // Constructeur par défaut
{{ Ellipse(float x, float y, float a, float b);
m_cX = m_ cY = 0;
Ellipse e1; Ellipse(const Ellipse & e);
}m_a = m_b = 1;
Ellipse e2(2.5, 6.5, 12, 15); Ellipse e3(e1); // e3 est un clone de e1 protected :
float m_cX, m_cY; float m_a, m_b;
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 …
Ellipse e4 = e1; // e4 est un clone de e1 return 0; }
public :
void deplace(float dx, float dy); void zoom(float z) ; float surface() ; };
Destructeur de classe
- Fonction membre systématiquement appelée juste avant la destruction d’un objet
- Porte le nom de la classe et est précédé de ~
- Pas de type de retour
- Pas d’arguments
- Un seul par classe
- Permet de libérer les ressourcesellipse.h ellipse.cpp prog.cpp
#include “ellipse.h”
#include « ellipse.h » class Ellipse {Ellipse::Ellipse()
int main() public :{
{ Ellipse(); // Constructeur par défaut
m_cX = m_ cY = 0;
Ellipse e; Ellipse (float x, float y, float a, float b);
m_a = m_b = 1;
Ellipse* pE = new Ellipse(2.5, 6.5, 12, 15); Ellipse(const Ellipse & e); }~Ellipse(); // Destructeur
etc …
delete pE; // appelle le destructeur pour pE
protected :
float m_cX, m_cY; float m_a, m_b;
return 0; Ellipse::~ Ellipse() {
// Le destructeur est implicitement appelé pour e. // Libération des ressources
} public :}void deplace(float dx, float dy);
void zoom(float z); float surface(); };void Ellipse::deplace(float dx, float dy)
{
m_cX += dx; m_cY += dy; }etc …
télécharger gratuitement Programmation Orienté Objet en C++(science 5)
