Cours Programmation Orientée Objet en C++

Université des Frères Mentouri – Constantine-1
Faculté des ST - Département d'Electronique
Dr. Amina HAMEURLAINE
amina.hameurlaine@umc.edu.dz
2017/2018
Cours Programmation Orientée Objet en C++ Dr. A.HAMEURLAINE

A l'issu de ce cours, l'apprenant sera capable de:
 Connaitre les différents paradigmes de la programmation;
 Connaitre les principales différences entre le paradigme procédural et
orienté objet;
 Apprendre les concepts de base de la programmation orientée objet;
 Apprendre à implémenter des programmes orientés objet en C++.

Pour pouvoir suivre ce cours avec succès, il faut au préalable:
 Maîtriser les notions de base de l’algorithmique;
 Maîtriser les notions de base de la programmation procédurale;
 Maîtriser les notions de base du langage C ou C++.

Chapitre 1: Introduction générale
Chapitre 2: Notion de base de la POO
Chapitre 3: Classe et Objet
Chapitre 4: Héritage et Polymorphisme

Développement d’un logiciel
Analyse
Conception
Implémentation
Test
Maintenance
Client
Cahier
de charges
Livraison
 Etude des besoins des utilisateurs;
Reformulation du cahier des charges sous une
forme exploitable en conception.
 Définition de l'architecture logicielle;
Définition du comportement de l'application.
 Implémentation des fonctionnalités définies
lors de phases de conception: Programmation.
Vérification de conformité de l'application
avec le cahier des charges.
 comprenant toutes les actions correctives
(maintenance corrective) et évolutives
(maintenance évolutive) sur le logiciel.

Développement d’un logiciel
Analyse
Conception
Implémentation
Test
Maintenance
Client
Cahier
de charges
Livraison
Méthodes et Langages de
Modélisation:
SADT, SA-RT, MERISE, OMT,
UML, …
Langages de Programmation:
Fortran, C, Ada, SmallTalk, Java,
C++, …

 Langage de Programmation
 Un programme est une suite d'instructions permettant d'exécuter
des actions sur un ordinateur.
 Ces instructions sont écrites dans un langage dit "langage de
programmation".
=> Programmer consiste à construire un ensemble ordonné
d'instructions en utilisant un langage de programmation.

 Langage de programmation:
Programme écrit en
langage machine:
Programme executable
Traduction:
Compilation/Interprétation
Un programme est écrit
dans un langage de
programmation :
Code source
Tous les langages de programmation ont le même but: nous permettre de parler à
l'ordinateur plus simplement qu'en binaire.

 Classement des Langages de Programmation par
«niveau»:
En programmation, la notion
de « niveau » est relative.
Il n'existe pas de méthode
particulière qui permettrait de
déterminer objectivement si
un langage peut être
considéré de bas niveau ou
de haut niveau.
openclassrooms.com

 Le paradigme d'un langage:
 Il s’agit des différentes façons de raisonner et d’implémenter une
solution à un problème en programmation.
 Il existe au moins 20 paradigmes différents et chaque paradigme
amène une technique différente de programmation.
 les plus généraux paradigmes sont:
• La programmation impérative (procedurale)
•La programmation fonctionnelle
•La programmation logique
•La Programmation Orientée Objet (POO)

 La programmation impérative (procédurale):
Un programme impératif n’est rien de plus qu’une suite d’instructions. Il
peut donc être assimilé en quelque sorte à une recette de cuisine, il suffit
de lire les instructions et les exécuter les unes après les autres.
Exemples de langages : Assembleur, Pascal, C.

 La programmation fonctionnelle:
− Un programme est défini avec des fonctions pures.
− Le paradigme fonctionnel est basé sur l'idée d'évaluer une formule, et
d'utiliser le résultat pour autre chose.
− Tous les traitements sont faits en évaluant des expressions et en
faisant appel à des fonctions.
Exemples de langages: Lisp, Scala, Erlang, F#.

 La programmation logique:
− Le principe est de définir une liste de faits (axiomes) et de règles de
logique qui leur associent des conséquences.
− Utilisé pour les démonstrations automatiques de théorèmes.
Exemples de langages: ProLog, SQL.

 La programmation Orientée Objet (POO):
Le principe est ici de programmer des objets, qui représentent un concept,
un objet physique ou un ensemble de données et les actions qui lui sont
rattachées, plutôt que de ne voir ces ensembles uniquement d’un point de
vue procédural.
Exemples de langages: SmallTalk, Java, C++.

prolland.free.fr

Programmation Procédurale V.s Programmation Orientée Objet
Données Traitements
Données
Traitements
Données
Traitements
Données
Traitements
Données
Traitements
Un programme est composé de
plusieurs procédures /fonctions qui
effectuent un traitement sur des
données.
 Les données et les traitements sont
séparés.
Il n’existe pas un lien directe
(sémantique) entre les données et le
traitement: passage des arguments.
Un programme est composé d’un
ensemble d’objets qui contiennent:
 des données ”internes”
 des traitements manipulant ces
données.
 Les données et leurs traitements
sont regroupés dans une seule
entité: objet.

Exemple: Calcule de surface d’un rectangle.
Problème: Programmation Procédurale

Traitement
Données
Passage des arguments
Les données et leurs
traitements sont
séparés;
Le code n’est pas
lisible;
Réutilisation très
difficile!

"Pourquoi le logiciel n'est-il pas comme le matériel ?
Pourquoi tout nouveau développement doit-il repartir de zéro ?
Il devrait y avoir des catalogues de modules logiciels, comme il y a des
catalogues de puces de circuits intégrés : pour construire un nouveau système,
on devrait commander des composants dans les catalogues et les combiner,
plutôt que de réinventer la roue à chaque fois....."
Bertrand Meyer – 2000
Conception et programmation par objets

Solution: Programmation Orientée Objet
double largeur
double hauteur
double surface( )
{…..}
Rectangle
largeur = 4
hauteur = 2
rect1
largeur = 5
hauteur = 8
rect3
largeur = 3.2
hauteur = 4.2
rect2
rect1.surface( ); rect2.surface ( ); rect3.surface( );
Objets
Classe

Solution: Programmation Orientée Objet
double largeur
double hauteur
double surface( )
{…..}
Rectangle
largeur = 4
hauteur = 2
rect1
largeur = 5
hauteur = 8
rect3
largeur = 3.2
hauteur = 4.2
rect2
Objets
Classe
Les données et leurs
traitements sont
regroupés;
Le programme est
plus lisible;
=> Modularité
Réutilisabilité

Approche Orientée-Objet
 Offre une manière claire de concevoir une architecture modulaire.
 Permet d'écrire des programmes facilement lisibles.
 Permet une maintenance et une évolution des logiciel plus aisée.
L’approche Orientée-objet permet de produire des
programmes plus claires et plus robustes.

Approche Orientée-Objet
Conception Programmation
Langages de
Modélisation
Orientée-Objet
Langages de
Programmation
Orientée-Objet
Exemple: UML Exemple: C++

UML: Unified Modeling Language
 Notion standard pour l’analyse et la conception des logiciels.
 Adapté à la modélisation de tous types de systèmes.
 Il s’agit d’un langage graphique de modélisation objet
permettant de spécifier, de construire, de visualiser et de
décrire les détails d’un système logiciel.
 UML définit neuf types de diagrammes divisés en deux catégories:
Diagrammes statiques:
structurels
Diagrammes dynamiques:
comportementaux
Diagramme de cas d’utilisation,
Diagrammes de classes,
Diagrammes d’objets,
Diagrammes de composants,
Diagrammes de déploiements.
Diagrammes d’activités,
Diagrammes de séquences,
Diagrammes d’états-transitions
Diagrammes de collaborations.

Langage C++
 Le langage C++ est une évolution du langage C avec plusieurs nouveautés.
 Il a été crée en 1983 par Bjarne Stroustrup, un informaticien originaire du
Danemark.
 Le C++ est un langage multi-paradigmes: on peut programmer de différentes
façons (procédurale, fonctionnelle, Orientée Objet).
 C’est l'un des langages de programmation les plus utilisés actuellement (très
populaire).
 Il est rapide, ce qui en fait un langage de choix pour les applications critiques
qui ont besoin de performances, les jeux vidéo par exemple.
 Il est portable: un même code source peut théoriquement être transformé
sans problème en exécutable sous Windows, Mac OS et Linux.
 Il existe de nombreuses bibliothèques pour le C++. Les bibliothèques sont
des extensions pour le langage.

Encapsulation/Abstraction
Héritage
Polymorphisme
1
2
3
Mieux organiser les
programme dans
le sens de la:
robustesse
modularité
lisibilité
maintenance

Encapsulation/Abstraction1
 L'encapsulation est le fait de pouvoir regrouper
dans une seule et même entité des données
(attributs) et des traitements qui agissent sur ces
données (méthodes) .
 Avec la notion d'abstraction on peut travailler avec
des entités abstraites au lieux de travailler avec des
descriptions détaillées des données.
double largeur
double hauteur
double surface( )
{…..}
Rectangle
Se focaliser sur l’essentiel, et cacher les détailles
largeur = 4
hauteur = 2
rect1
largeur = 3.2
hauteur = 4.2
rect2
largeur = 5
hauteur = 8
rect3
Interfaces

 Pour utiliser une classe ou un nouveau type d’objet, nous n’avons
besoin d’en connaitre que l’interface d’utilisation qui prévue par le
programmeur .
=> Dissimuler les détailles d’implémentation interne (qu’il n’est pas
utile d’en connaitre).
Protection des données et du fonctionnement interne

Programmeur
Utilisateur
Programmeur
Développeur
Ecriture du programme:
Définition des classes
Attributs + Méthodes
Utilisation du programme:
Utilisation des classes via leurs
objets
Interfaces
Méthodes visibles

Les droits d’accès:
Chaque attribut et chaque méthode d'une classe peut posséder son
propre droit d'accès. Il existe trois types de droits d'accès:
Accès public: l'attribut ou la méthode peut être appelé depuis
l'extérieur de la classe.
Accès privé: l'attribut ou la méthode ne peut pas être appelé depuis
l'extérieur de la classe.
Accès protégé: tout attribut ou méthode protégé(e) n'est accessible
que dans les descendants (les sous-classes).

 L'héritage est un concept très important qui représente une part non
négligeable de l'intérêt de la programmation orientée objet.
 Il consiste à définir différents niveaux d'abstraction.
 L'héritage établit une relation de spécialisation/généralisation entre
les classes.
 Il permet de construire des classes (sous-classes) à partir de classes
existantes (classes mères, super classes, classes de bases).
Une sous-classe est une spécialisation d'une classe appelée sa
superclasse;
 une classe hérite des caractéristiques de sa superclasse : elle en
partage les attributs et les méthodes.
Héritage2

Héritage2
Attributs
méthodes
Classe A
Classe B Classe C
Généralisation
Spécification
Exemples:
 une voiture est un véhicule (Voiture hérite de Véhicule) ;
un bus est un véhicule (Bus hérite de Véhicule) ;
un corbeau est un oiseau (Corbeau hérite d'Oiseau) ;
 un chirurgien est un docteur (Chirurgien hérite de Docteur).
Eviter la duplication
du code
Organiser le code.

Le polymorphisme est un mécanisme qui permet à une sous classe de
redéfinir une méthode dont elle a hérité tout en gardant la même
signature de la méthode.
 Grace a l'héritage, le même code pourra être appliqué a différentes
sous-classes .
 Grace au polymorphisme, le même code appliqué a différentes
sous-classes pourra avoir un comportement différent (propre a chaque
sou classe).
Exemple:
Polymorphisme3
Calcul_salaire()
Employé
Calcul_salaire()
secrétaire
Calcul_salaire()
Ingénieur

 Une classe est une structure regroupant les mêmes types de données et
les mêmes traitements d’une famille d'objets.
 Une classe présente une description abstraite d’un ensemble d’objets.
 Une classe est composée de plusieurs membres dont chacun est soit:
un attribut : variable typée,
une méthode: ensemble d’instructions de traitement.
attribut1
attribut2
Attribut3
…..
méthode1()
méthode2()
….
ClasseA
Attributs
Méthodes

- attribut1: type
- attribut2:type
#attribut3: type
+méthode1()
+méthode2()
Classe A
Droits d’accès
+ public
- private
# protected
Représentation UML
class NomClasse {
private:
type attribut1;
type attribut2;
protected:
type attribut3;
public:
type Methode1(arguments)
{ // définition de la methode1 }
type Methode2(arguments)
{ // définition de la methode2}
};
Représentation C++
1.
Règle d’encapsulation:
Tous les attributs d’une classe
doivent toujours êtres privés.
Attributs
Méthodes

- hauteur: double
- largeur: double
+surface()
Rectangle
class Rectangle {
private:
double hauteur;
double largeur;
public:
double surface ()
{ return hauteur * largeur; }
};

- hauteur: double
- largeur: double
+surface()
Rectangle
class Rectangle {
private:
double hauteur;
double largeur;
public:
double surface ()
};
Méthode = Fonction

Il existe 2 types de méthodes .
 Des méthodes qui modifient l’ état de l’objet => Actions
 Des méthodes qui ne changent rien à l’objet => Prédicats
 Pour indiquer qu’une méthode est un prédicat, on utilise le mot clé
const.
Exemple:
public:
double surface () const

- hauteur: double
- largeur: double
+surface()
RectangleUn objet est une instance d'une classe.
largeur = 4
hauteur = 2
rect1
largeur = 3.2
hauteur = 4.2
rect2
largeur = 5
hauteur = 8
rect3
class Rectangle {
private:
double hauteur;
double largeur;
public:
};
Int main() {
Rectangle rect1;
rect1.hauteur = 2;
rect1.largeur = 4;
cout <<rect1.surface()<<endl;
}

class Rectangle {
private:
double hauteur;
double largeur;
public:
};
Int main() {
Rectangle rect1;
rect1.hauteur = 2;
rect1.largeur = 4;
cout <<Rect1.surface()<<endl;
}
 Tous les attributs sont
en mode privé!
On peut pas y accéder
depuis l’extérieur de la
classe!!!!
 Comment faire pour les
initialiser alors??!!
Problème!

class Rectangle {
private:
double hauteur;
double largeur;
public:
void setHauteur (double h) { hauteur = h; }
void setLargeur (double L) { largeur = L; }
double getHauteur () const { return hauteur ; }
double getLargeur () const { return largeur ; }
};
Int main() {
Rectangle rect1;
rect1.setHauteur (2); rect1.setLargeur (4);
cout <<rect1.getHauteur()<<endl;
cout <<rect1.getLargeur()<<endl;
cout <<rect1.surface()<<endl;
}
Setter: Action qui permet:
 Modification des valeurs des attributs;
 Affectation des valeurs aux attributs.
=> Pas de retour .
 Gettre: Prédicat qui permet:
 Consultation d’un attribut: lecture
seule.
=> Retour de la valeur d’un attribut.
Solution 1: Manipulateurs (setters) / Accesseurs (getters)

Solution 2:
En c++, il y a des méthodes prédéfinies qui permettent d’initialiser
les attributs des objets.
Les Constructeurs
les constructeurs servent à construire les objet en mémoire.
Leur rôle principal est d'initialiser les attributs des objets.
 Ils sont appelés lors de la création des objets.
Un constructeur est une méthode sans aucun type de retour.

Syntaxe C++
Il faut que le constructeur ait le même nom que la classe.
Le constructeur ne doit rien renvoyer, pas même void !
Ou:
public:
nomConstructeur (arguments)
{ //Initialisation des attributs }
public:
nomConstructeur (arguments) : initialisation1, initialisation2 //liste
//d'initialisations
{ } //le corp est vide

Exemple:
ou
class Rectangle {
private:
double hauteur;
double largeur;
public:
Rectangle (double h, double L) {
hauteur = h;
largeur = L; }
};
Int main() {
Rectangle rect1(2, 4);
}
class Rectangle {
private:
double hauteur;
double largeur;
public:
Rectangle (double h, double L) : hauteur(h), largeur(L)
{ }
};
Int main() {
}

Exemple:
ou
class Rectangle {
private:
double hauteur;
double largeur;
public:
Rectangle (double h, double L) {
hauteur = h;
largeur = L; }
};
Int main() {
}
class Rectangle {
private:
double hauteur;
double largeur;
public:
{ }
};
Int main() {
}
On appelle le constructeur Rectangle pour l’objet rect1 avec les paramètres 2 et 4

Attention!
class Rectangle {
private:
double hauteur;
double largeur;
public:
{ }
};
Int main() {
Rectangle rect2(6);
Rectangle rect3;
Rectangle rect4(rect1); // constructeur de copie
}
Mais si on appelle le constructeur
avec un seul paramètre ou bien
sans mettre des paramètres?!

Solution:
Déclaration des constructeurs
avec initialisation de 0.
class Rectangle {
private:
double hauteur;
double largeur;
public:
Rectangle (double h=0, double L=0) : hauteur(h),
largeur(L) { }
};
Int main() {
Rectangle rect2(6);
Rectangle rect3;
Rectangle rect4(rect1); // constructeur de copie
}
Note:
Un constructeur qui n’a pas de
paramètres s’appelle
«constructeur par default ».

 Le destructeur est une méthode appelée lorsque l'objet est supprimé de la
mémoire.
 Son rôle principal est de libérer la mémoire (via des delete) qui a été
allouée dynamiquement.
 Il porte le même nom que la classe;
 Il est appelé automatiquement `a la fin du programme.
Ou: ~nomDestructeur(){
delete attribut1;
delete attribut2;
}
~nomDestructeur()
{ }

On peut définir des méthodes à l’extérieur de la classe.
La classe ne contient que des prototypes (déclaration seule);
Les détailles des méthodes sont à l’extérieur de la classe.
La définition de la méthode doit être reliée à la classe concernée en
utilisant l’operateur :: .
class NomClasse {
private:
type attribut1;
type attribut2;
public:
type nomMethode(arguments); // prototype de la methode1
};
Type NomClasse : : nomMethode(arguments)
{ // définition de la methode1
}

 On peut séparer la déclaration des classes et la définition des méthodes
dans des fichiers différents pour avoir un code plus modulaire.
 Pour chaque classe, on peut créer :
un header (fichier *.h) qui contiendra les attributs et les prototypes de
la classe ;
un fichier source (fichier *.cpp) qui contiendra la définition des
méthodes et leur implémentation.

Exemple:
 Fichier (Rectangle.h) : déclaration de la classe Rectangle, ses attributs et
les prototypes de ses méthodes;
Dans les fichiers .h, il est recommandé
de ne jamais mettre la directive using
namespace std;
Pour les variables de type string, il faut
rajouter le préfixe std:: devant
chaque string du .h.

Exemple:
 Fichier (Rectangle.cpp):définitions des méthodes de la classe Rectangle.
On peut aussi rajouter ici
un using namespace std;.
On a le droit de le faire car on
est dans le .cpp.

 Il est possible que tous les objets d’une même classe partagent une ou
plusieurs données qui seront identiques pour tous ces objets.
=> attributs statiques
 Ils ressemblent à des variables globales dont la portée est limitée à cette
classe.
 Leur déclaration est précédée du mot-clé static.
 Leur initiation se fait en dehors de la déclaration de la classe.
class NomClasse {
private:
static type attribut1;
};
type NomClasse :: attribut1 = valeur;

Exemple: class Rectangle {
private:
double hauteur; double largeur;
public:
static int nb_instances;
Rectangle (double h=0, double L=0) : hauteur(h), largeur(L)
{++ nb_instances;
cout <<" Rectangle "<<nb_instances << endl;
cout<<"la hauteur est: "<<h<<endl;
cout<<"la largeur est: "<<L<<endl;
cout<<endl; }
double surface () const { return hauteur * largeur; }
~ Rectangle () {
--nb_instances;
cout <<"Il reste " <<nb_instances <<" rectangle n"; }
};
int Rectangle::nb_instances=0 ;
Int main() {
Rectangle rect2(6);
Rectangle rect3;Cours Programmation Orientée Objet en C++ Dr. A.HAMEURLAINE

 une méthode statique est partagée par toutes les instances d’une même
classe.
 Au lieu d’être appelée avec un objet de la classe, elle est appelée avec le
nom de la classe.
 Elle ne peut pas accéder aux données membres d’un objet et elle ne peut
pas appeler une méthode non statique.
 Les méthodes statiques sont généralement utilisées pour manipuler les
données statiques.
class NomClasse {
public:
static type methode () { return variable ;}
};
type NomClasse :: attribut1 = valeur;

Exemple:
class Rectangle {
private:
double hauteur; double largeur;
public:
static int nb_instances;
Rectangle (double h=0, double L=0) : hauteur(h), largeur(L)
{++ nb_instances;
cout <<"Rectangle "<<nb_instances << endl;
cout<<"la hauteur est: "<<h<<endl;
cout<<"la largeur est: "<<L<<endl;
cout<<endl; }
static int affiche () { return nb_instances; }
~ Rectangle () {
--nb_instances;
cout <<"Il reste " <<nb_instances <<" rectangle n"; }
};
int Rectangle::nb_instances=0 ;
Int main() {
Rectangle rect2(6);
Rectangle rect3;
cout<<" Nombre d’objets crees = "<<Rectangle :: affiche ()<< endl;
} Cours Programmation Orientée Objet en C++ Dr. A.HAMEURLAINE

 Une fonction extérieure à une classe A (fonction globale ou fonction
membre d’une autre classe) peut être déclarée amie de classe A.
=> toutes les données et méthodes membres de cette classe
(privées/publics) deviennent accessibles pour cette fonction.
 Une même fonction peut être amie de plusieurs classes.
 La déclaration d’une fonction comme amie à une classe A doit être faite à
l’intérieur de la classe A en utilisant le mot-clé friend.
 Seules les fonctions déclarées amies à l’intérieur d’une classe peuvent
accéder à cette classe: contrôle d’accès.
class ClasseA {
…..
puclic:
friend type nomFonction (arguments); //fonction amie globale
friend type ClasseB :: nomMethode (arguments); //fonction amie membre d’une classe B
};

 Une classe A peut être déclarée amie d’une classe B
=>tous les membres de la classe B deviennent accessibles pour la
classeA.
Note:
si la classe A est amie de la classe B, ¸ca ne veut pas dire
que B est amie de la classe C.
class ClasseA {
…..
};
class ClasseB {
….
puclic:
friend class ClasseA; //ClasseA est amie de ClasseB
};

L’association est une relation structurelle précisant que les objets d’une
classe sont reliés aux objets d’une autre classe.
Elle est représentée par un attribut.
Elle est définie par : un rôle et une multiplicité.

 L'héritage entre classes symbolise les relations hiérarchiques entre les
concepts.
 Si une classe B hérite d'une classe A, on dit A est la classe mère et B la
classe fille.
 La classe B hérite des attributs et des méthodes de la classe A.
 Un objet de la classe B est aussi un objet de la classe A.
 on dit aussi que B dérive de A ou encore que B est dérivée de A.
 La relation d'héritage est une relation de généralisation-spécialisation :
B est une spécialisation de A et A est une généralisation de B.
Classe A
Classe CClasse B
Classe mère
Classe filleClasse fille

 Une super-classe :
est une classe mère (ou parent);
déclare les attributs/méthodes communs;
peut avoir plusieurs sous-classes.
 Une sous-classe :
est une classe fille (ou enfant);
hérite des attributs et des de la super-classe;;
peut avoir une ou plusieurs sous-classes.

class NomSousClasse : public NomClasseMere {
};
Syntaxe C++
Exemple: la classe Rectangle est une sous-classe de la classe Forme.
class Forme { };
class Rectangle : public Forme { };

 Les sous classes ne peuvent accéder qu’aux
données membres publics et protégées
(protected) de la classe mère.
Les méthodes des sous classes n’ont pas
accès aux membres privés de la classe
mère.
Les membres protégés sont accessibles
uniquement par les objets de la
même classe et par tous les objets
des sous-classe.
- attribut1: type
- attribut2:type
#attribut3: type
+méthode1()
+méthode2()
Classe A
Classe CClasse B

Syntaxe C++:
class NomClasse Mere{
protected:
type attribut1;
type attribut2;
public:
type Methode1(arguments) { }
type Methode2(arguments) { }
};
class NomSousClasse : public NomClasseMere {
…..
};

Exemple:
class Polygone {
protected:
double hauteur;
double largeur;
public:
void set_values (int h, int L) { hauteur=h; largeur=L; }
};
class Rectangle : public Polygone {
};
classTriangle : public Polygone {
double surface () const { return largeur* hauteur / 2; }
};

 Héritage public : l'accès à la classe mère peut être effectué partout
dans le code.
 Héritage privé (private ): l'accès à la classe mère est effectué
«uniquement» dans la classe fille .
 Héritage protégé (protected ): l'accès à la classe mère est effectué
dans la classe fille ainsi que toute ses classes dérivées.

Exemple:
class ClasseA {……};
class ClasseB : public ClasseA {…..};
class ClasseC : protected ClasseA {…..};
class ClasseD : private ClasseA {…..};
int main () {
ClasseB b; ClasseC c; ClasseD d; Classe A * ptr;
ptr = &B; // OK
ptr = &C; // Erreur (ca ne marchera que dans C et toutes ses dérivées)
ptr = &D; // Erreur (ca ne marchera que dans D
}

 A la construction d'une classe fille, le constructeur de la classe mère est
appelé avant tout autre chose.
le constructeur de la classe dérivée appelle le constructeur par défaut
(constructeur sans paramètres) de la classe de base.
 Dans le cas d’un constructeur avec paramètres, le constructeur de
base est exécuté en premier.
 Lors de la destruction d'un objet d'une classe dérivée, le destructeur de la
classe mère est appelé automatiquement après le destructeur de la classe
fille.
=> Les appels aux destructeurs se font dans l'ordre inverse des appels
aux constructeurs.
NomConstructeur_sousClasse (parameters) : NomConstructeur_ClasseMere
(parameters) {...}

Exemple:
class ClasseA {
…..
Public:
ClasseA () { cout << “constructeur sans paramètres - constructeur par défaut" <<endl; }
ClasseA (int a) { cout << " constructeur avec un paramètre " <<endl; }
~ ClasseA () {cout << " Destructeur " <<endl; }
};
class ClasseB : public ClasseA {
…..
Public:
ClasseB (int a) : ClasseA (a) { cout << " constructeur avec un paramètre " <<endl; }
~ ClasseB () {cout << " Destructeur " <<endl; }
};
int main () {
ClasseB b(1);
}

 Une classe peut hériter des attributs et des
méthodes de différentes classes de base.
Syntaxe: Classe A
Classe C
Classe B
class ClasseC : publicClasseA, publicClasseB {
…..
};

 Le polymorphisme est un mécanisme qui permet à une sous classe de
redéfinir une méthode dont elle a hérité tout en gardant la même signature de la
méthode.
Grace à l'héritage, le même code pourra être appliqué aux différentes sous-
classes .
Grace au polymorphisme, le même code appliqué aux différentes sous-
classes pourra avoir un comportement différent.
 Le polymorphisme représente la capacité du système à choisir
dynamiquement la méthode qui correspond au type de l’objet en cours de
manipulation.

Exemple 1: Héritage simple
Chaque classe affiche un
message différent.
Ceci est un vehicule.
Ceci est une moto.

Pour le compilateur, à l'intérieur de la
fonction, on manipule un Vehicule.
appeler la « version Vehicule» de
la méthode afficher() et pas la «
version Moto» .
 C'est le type de la variable qui
détermine quelle fonction membre
appeler et non sa vraie nature.
résolution statique des liens
 comportement non polymorphe
 Problème: Résolution statique des liens

 Solution: Résolution dynamique des liens.
Lors de l'exécution, le programme doit utilises la bonne version des méthodes
=> il doit savoir si l'objet est de type mère ou de type fille.
 => Il faut utiliser des méthodes virtuelles + des références / pointeurs.

 Méthode virtuelle et référence:
L’utilisation de méthodes virtuelles avec les références permet d’exprimer des
différences de comportement entre des classes de la même famille.
=> Ces différences sont ce qui engendre un comportement polymorphe.
classVehicule{
....
public:
virtual void afficher( );
….
};
…
void presenter(Vehicule &v )
// ou :
// void presenter(Vehicule const&v )
{ v.afficher ( ); }

Ceci est une moto.
En utilisant des fonctions
virtuelles ainsi qu'une référence sur
l'objet, la fonction presenter() peut
correctement choisir la méthode à
appeler.
résolution dynamique des liens
Un même morceau de code a eu
deux comportements différents
suivant le type passé en argument.
 comportement polymorphe

Méthode virtuelle et pointeurs
Ceci est une moto.

 Méthode virtuelle et pointeur
Un même morceau de code a eu
deux comportements différents
suivant le type passé en argument.
 comportement polymorphe
openclassrooms.com

Les fonctions virtuelles pures:
 Problème:
 Les voitures ont 4 roues et les motos
2 mais, pour un véhicule en général,
on ne peut rien dire !
 si on ne déclare pas la fonction dans
la classe mère, alors on ne pourra pas
l'utiliser depuis notre collection
hétérogène!

Solution: Fonction virtuelle pure.
 Si l'on ne sait pas quoi mettre dans le corps d'une méthode de la classe
mère, on peut la déclarer virtuelle pure.
 Une fonction membre est dite virtuelle pure lorsqu’elle est déclarée de la
façon suivante : virtual type nomMethode(paramètres) = 0;
une méthode virtuelle peut être redéfinie dans une classe fille .
une méthode virtuelle pure doit être redéfinie dans une classe fille.

Exemple:

Les Constructeurs:
Un constructeur ne peut pas être virtuel: il sait quel type d’objet il va
construire.
=> pas besoin de résolution dynamique ses liens.
On ne peut pas appeler de méthode virtuelle dans un constructeur.

2. Les Destructeurs:
Un destructeur doit toujours être virtuel si on utilise le polymorphisme.
Exemple:
Quel destructeur va
être appelé? !

2. Les Destructeurs:
Un destructeur doit toujours être virtuel si on utilise le polymorphisme.
Exemple:
=> Il faut appeler le bon destructeur!!!
C'est le destructeur de Vehicule qui va être appelé et pas celui
de Voiture!

 Pour avoir une liste de différents types d’objets, il faut utiliser un tableau
dynamique de pointeurs « vector ».
Exemple:
Note:
Il ne faut pas
oublier d’inclure
la bibliothèque
<vector>
Ceci est une voiture avec 5 portes et coutant 15000 euros.
Ceci est une moto allant a 212.5 km/h et coutant 2000 euros.

 Une classe qui possède au moins une méthode virtuelle pure est une classe
abstraite.
 Une classe abstraite ne peut pas être instanciée : on ne peut créer d’objet à
partir d’une classe abstraite.
Exemple:
 Classe Vehicule: si on pouvait créer un objet Vehicule, alors on pourrais
essayer d'appeler la fonction nbrRoues() qui n'a pas de corps et ceci n'est
pas possible.

Exemple:
l'appel à la méthode
nbrRoues() est
polymorphique: pointeur +
méthode virtuelle.
=> C'est la « version Voiture»
qui est appelée, même si la
«versionVehicule» n'existe
pas.

 «Apprendre le C++ », M. Hamemerchmidt.
 «Apprendre le C++ », C. Delonnoy.
 « Programmation en Langage C++ : Cours etTravaux Pratiques », B.
Boukhezzar.
 http://www.cplusplus.com/doc/tutorial/
 https://openclassrooms.com/courses/programmez-avec-le-langage-
c/qu-est-ce-que-le-c-2
 https://fr.coursera.org/learn/cpp-poo
 http://carl.seleborg.free.fr/cpp/cours/index_cours.html

Cours Programmation Orientée Objet en C++

Contenu connexe

Tendances (20)

Similaire à Cours Programmation Orientée Objet en C++ (20)

Dernier (20)

Cours Programmation Orientée Objet en C++