Année Universitaire

2023 - 2024

Atelier C++
Filière: RT2/GL2

Enseignants : Asma Ben Hassouna

Mohamed Dhia Eddine Kandara

1
 C++: Plan

I - Introduction aux Langages Orientés Objets

 Qu’est-ce qu’un objet/classe ?
 Propriétés d'un objet

II- Les classes en C++

 Interface de classe
 Implantation
 Constructeur / destructeur
 Héritage / polymorphisme
 Abstraction

2
Logiciels à utiliser:
CodeBlocks

3
 C++: Présentation

 Le C++ est le langage de programmation le plus utilisé par les

développeurs,

 Il permet d'aborder le développement sous plusieurs paradigmes :

programmation générique, procédurale et orientée objet.

 C'est un langage compilé, ce qui signifie que le code source est

traduit en code objet, ou binaire pour que la machine puisse
l'exécuter.

 C++ est un langage de programmation orienté objet, à la fois fiable

et puissant
4
 Programmation orientée objet
vs. procédurale
 Avantages :
– Programmation plus claire :
les fonctions sont rattachées à un type de données
– 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,
– Modularité accrue :
possibilité de réutiliser le code des classes.
 Inconvénients :
– Le programme résultant peut être moins efficace (en
termes de taille mémoire et de rapidité)
5
Concepts orientée objet

6
 Notion d’Objet
 Un objet est une entité informatique comprenant:
• des données membres (ou champs/attributs/variables
d’instances)
• des fonctions membres (ou méthodes/routines)

 Un objet possède un état :

L’état est donné par la valeur de ses attributs à un instant
donné.
Il peut varier au cours du temps.

 Un objet possède une identité :

qui permet de le distinguer des autres objets indépendamment
de son état,
qui est construite grâce à un identifiant (matricule du voiture
par exemple)
7
 Notion de Classe
• Une classe est un type de données défini par l'utilisateur,

• Une classe est comme un modèle/interface pour un objet.

• Une classe d’un objet décrira donc :

– des données membres.
– des méthodes membres qui seront des fonctions

• Les membres d’une classe sont accessibles et utilisables en

créant une instance de cette classe.

8
 Représentation d’une Classe (UML)
Véhicule Nom de la classe CompteBancaire
nbVitesses
numéro
Vision Matricule
Données membres solde
interne tailleRoues ou attributs
couleur propriétaire
(privé)
Poids Créditer()
Fonctions membres Débiter()
Accélérer() ou méthodes
Fermer()
Freiner()
Vision ChangerVitesse()
Numéro()
externe Solde()
GetCouleur()
(public) Propriétaire()
GetMatricule()

Remarque:
L'accès aux données et méthodes est réglementé (partie privé/partie publique)
la vision externe peut aussi contenir des variables publiques
9
Représentation d’une Classe (C++)

Type d’attributs

Entêtes de
méthodes

10
 Classe et Objet
 Ne pas confondre classe d'objets et instance d'objet

 Une classe désigne un groupe d’objets similaires: la classe

Chien

11
 Classe et Objet:
Exemple 1

Une instance de la classe fait référence à un objet précise: le

berger allemand de mon voisin est une instance de la classe
Chien
12
Classe et Objet:
Exemple 2

13
 Concept Orienté Objets
Encapsulation
 On appelle encapsulation le regroupement des variables
et des fonctions au sein d'une même entité:

14
 Concept Orienté Objets
Abstraction
 On appelle abstraction le fait de masquer toutes les
informations non pertinentes d'un objet à des fins de
simplification et d'efficacité.

 Par exemple :
Il est possible de représenter un objet véhicule par trois
champs uniquement:
1.matricule
2.modèle
3.couleur
(et d’autres bien entendu)
15
.
 Mini-Projet 1
Gestion de formes géométriques: Ellipse/Cercle

Ellipse

Cercle

1) On a choisi de représenter l'ellipse par les attributs coordonnées de

son centre (cX, cY), par son grand axe a et par son petit axe b.

2) un Cercle est une forme spécifique d’une Ellipse

16
 Etape 1: Création de l’’interface Ellipse (1)

 Une interface est la description de la structure interne de la

classe.
 Une interface est définie dans un fichier header d’extension
« .h » et qui porte le nom de la classe (dans notre cas :
ellipse.h)

17
 Etape 1: Création d’interface Ellipse (2)

class Ellipse Visibilité de membres :

{ – public: membres
protected : accessibles à tous
Vision
interne float cX, cY;
– private: membres
float a, b; accessibles à partir de la
public : classe ; accès impossible par
l’extérieur
Ellipse();
Vision virtual ~Ellipse(); – protected: membres
externe
void deplace(float dx, float dy); accessibles à partir de la
classe et des classes
void zoom(float z); dérivées ; accès impossible
float surface(); par l’extérieur
void affiche();
}; 18
 Etape 2: Implantation des méthodes d’une Classe (1)

 C’est la définition des fonctions associées

 l’implantation des méthodes est effectuée dans un fichier d’extension
« .cpp » et qui porte le nom de la classe (dans notre cas : ellipse.cpp),
 le fichier ellipse.cpp doit commencer par inclure « ellipse.h »
Rappel Interface de la classe Ellipse
class Ellipse
{
protected :
float cX, cY;
float a, b;
public :
Ellipse();
virtual ~Ellipse();
void deplace(float dx, float dy);
void zoom(float z);
float surface();
void affiche();
}; 19
Etape 2: Implantation des méthodes d’une Classe (2)
#include <iostream>
Opérateur
#include "ellipse.h" de portée
using namespace std;

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

Ellipse::Ellipse()
{ {
cX += dx; //constructeur
cY += dy; }
} Ellipse::~Ellipse()
void Ellipse::zoom(float z) {
{ //destructeur
a *= z; }
b *= z;
} void Ellipse::affiche()
float Ellipse::surface() {
{ std::cout << "Ellipse d’axes: " << a<<" et " << b<< endl;
std::cout <<" de coordonnées:" <<cX <<" et " << cY<< endl;
return 3.14 * a * b/4;
}
} 20
 « std::cout »

 Librairie <iostream >

 Syntaxte:

std::cout << "message" << variable<<….. << entier<<endl;

possibilité d’afficher des valeurs/variable sans besoin de

préciser le format d’affichage,
le séparateur est « << »
21
 Etape 3: Instanciation d’une Classe (1)

 Instancier une classe est le fait de créer un objet ayant pour type
la classe déclarée (dans une fonction ou dans le main() par
exemple )
(analogue à une déclaration de variable)

22
 Etape 3: Instanciation d’une Classe (2)
Dans main.cpp par exemple :
#include "ellipse.h"
int main() Instanciation
{ statique de l’objet
Ellipse e; e, e étant une
variable de type
Ellipse
e.deplace(50, 0);
float s = e.surface(); Accès aux
e.zoom(1.5); membres par le
e.affiche(); "."

e.cX = 30; // Valide: oui/non?

e.deplace(20); // Valide: oui/non?
return 1;
23
}
 Etape 4: Exécution du programme principal
1. Exécuter votre programme,
2. Que pensez-vous des valeurs affichées?
3. Est-ce que les valeur cX, cY, a et b sont définies lors de
l’instanciation (la construction) de e ?

#include "ellipse,h"
void main()
{
Ellipse e;
e.deplace(50, 0)
float s = e.surface();
e.zoom(1.5);
e.affiche();
}
24
 Solution : 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

25
 Types de Constructeurs de classe

– constructeur par défaut : Ellipse();

• Ne contient aucun argument
• Automatiquement généré si aucun constructeur n’est défini
• A définir explicitement dans le cas contraire

– constructeur avec paramètres: Ellipse(float x, float y, float a, float b);

• Contient des arguments nécessaires pour initialiser les
attributs

– constructeur de copie: Ellipse(const Ellipse &e);

• 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
26
 Constructeurs de la classe Ellipse
ellipse.h ellipse.cpp main.cpp

class Ellipse #include "ellipse.h" #include "ellipse.h"

{
public : Ellipse::Ellipse() int main()
Ellipse(); // Constructeur par défaut {
cX = cY = 0;
{
Ellipse(float x, float y, float a, float b);
a = b = 1; Ellipse e1;
Ellipse(const Ellipse &e); //
Constructeur pour Clone } Ellipse e2(2.5, 6.5, 12, 15);
Ellipse e3(e1); // e3 est un
protected : Ellipse::Ellipse(float x, float y, float e, clone de e1
float cX, cY; float f) : cX(x), cY(y), a(e), b(f) {} Ellipse e4 = e1; // e4 est un
float a, b; clone de e1
Ellipse::Ellipse(const Ellipse & e)
e1.affiche();
public :
{ e2.affiche();
void deplace(float dx, float dy);
void zoom(float z) ; cX = e. cX; e3.affiche();
float surface() ; cY = e. cY; return 0;
void affiche(); a = e.a ; }
}; b = e.b;
}

//etc … le reste des méthodes

27
 Constructeurs avec paramètres

La notation:

Ellipse::Ellipse(float x, float y, float e, float f) : cX(x), cY(y), a(e), b(f) {}

Est Equivalente à

Ellipse::Ellipse(float x, float y, float e, float f)

{
cX=x;
cY=y
a=e,
b=f;
}
28
 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 ressources
 Destructeur de la classe Ellipse

ellipse.h ellipse.cpp prog.cpp

#include “ellipse.h” #include "ellipse.h"

class Ellipse
{ Ellipse::Ellipse() int main()
public : { {
Ellipse(); cX = m_ cY = 0; Ellipse e;
Ellipse (float x, float y, float a, float b); a = b = 1; Ellipse* pE = new Ellipse( 2.5, 6.5, 12, 5);
Ellipse(const Ellipse & e); }

virtual ~Ellipse(); // Destructeur etc … delete pE; // appelle le destructeur pour

pE
protected : Ellipse::~ Ellipse()
float cX, cY; { return 0;
float a, b; // Libération des
ressources // Le destructeur est implicitement appelé
public : } pour e.
void deplace(float dx, float dy); }
void zoom(float z);
float surface(); etc …
};

30
 Notion d’héritage

 L’idée est : "un B est un A

avec des choses en plus".
 La classe nouvellement créée,
dite classe dérivée, contient
les attributs et les méthodes
de la classe de base en plus
de nouveaux attributs et de
nouvelles méthodes propres à
la classe dérivée.

 L’héritage permet donc 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
31
 Notion d’héritage:
Exemple 1
• L'héritage: créer une nouvelle classe à partir d'une classe existante.

Véhicule classe de base ou classe mère

ou classe parente

Sans_Moteur Avec_Moteur classes dérivées

ou classes filles

Vélo Patinette Moto Scooter Mobylette

32
 Notion d’héritage:
Exemple 2
L’héritage permet de spécialiser une classe en définissant une relation
de type « est une sorte de ».

Un cercle est un spécialisation d'une ellipse, il en possède les même

propriétés/méthodes plus d'autres qui lui sont spécifiques. On dérive
donc la classe Cercle de la classe Ellipse qui est dérivé de la classe
Forme
Forme

Ellipse Rectangle

Cercle Carre

33
 Etape 5 : Implantation du classe Cercle
(Dérivée de Ellipse)
cercle.h main.cpp
#include “ellipse.h” #include "cercle.h"

class Cercle : public Ellipse int main()

{ {
public : Cercle c(5, 5, 15);
Cercle(); c. affiche();
Cercle (float x, float y, float diametre); return 0;
~ Cercle(); }
void affiche();
Le constructeur de la
};
classe dérivée appelle
généralement un des cercle.cpp
#include <iostream>
constructeurs de la
#include “cercle.h”
classe de base.
Cercle::Cercle(): Ellipse() { }
Cercle::Cercle(float x, float y, float diametre): Ellipse( x, y, diametre, diametre) {}
void Cercle::affiche()
{
std::cout << "Cercle de rayon " << a / 2 << "\n"; 34
}
Types d’héritage

35
 Propriétés héritage

• en C++, une classe peut être dérivée à partir de

plusieurs classes de bases (héritage multiple),

36
 Propriétés héritage

Si B hérite de A, alors toutes les instances de B sont aussi des

instances de A,
il est donc possible de faire :
Ellipse E;
Cercle C;
E = C; // Ok !
Propriété conservée lorsqu’on utilise des pointeurs :
Ellipse *pE;
Cercle *pC = &C;
pE = pC; // pointer sur un C c’est avant tout pointer sur un E
// Évidement, l’inverse n’est pas vrai :
C = E; // ERREUR !

pE = &E;
pC= pE; // ERREUR ! pointer sur un E n’est pas pointer sur un C 37
 Propriétés héritage

Conclusion :
Traiter un type dérivé comme s’il était son type de base est
appelé transtypage ascendant ou surtypage (upcasting)

A l’opposé, le transtypage descendant (downcast) pose un

problème particulier car leur vérification n’est possible qu’à
l’exécution.

38
 L’héritage

Propriétés héritage : Surcharge/Redéfinition(1/2)

/ / Classe de base
class Personne
{ protected surcharge
string nom; string cin;
public:
string getNom();
void afficher(){ cout redéfinition
<< nom << endl; }
void afficher(Personne
p){
cout <<
p.nom << endl;
cout <<
p.cin << endl;
}};
/ / Classe dérivée
class Etudiant : public Personne {
private:
string numEtud ;// ajouté
public:
string getNumEtud(); // ajout de
 L’héritage

Propriétés héritage : Surcharge/redéfinition(2/2)

Il ne faut pas mélanger la redéfinition et la surdéfinition :

Une surdéfinition ou surcharge (overloading ) permet

d’utiliser plusieurs méthodes qui portent le même nom au
sein d’une même classe avec une signature différente.
Une redéfinition (overriding ) permet de fournir une nouvelle
définition d’une méthode d’une classe ascendante pour la
remplacer. Elle doit avoir une signature rigoureusement
identique à la méthode parente.

Un objet garde toujours la capacité de pouvoir redéfinir une méthode

afin de la réécrire ou de la compléter.
 L’héritage

Propriétés héritage
Appel de constructeur (1/2)

 Comme une instance de Etudiant (classe dérivée) est avant

tout une instance de Personne (classe de base), dans le
constructeur de Etudiant, on explicite la façon de créer
l’instance Personne dans la liste d’initialisation.

 Le constructeur de Personne (classe de base) est appelé

avant le constructeur de Etudiant (classe dérivée).

Remarque : les destructeurs sont appelés dans l’ordre inverse.

 L’héritage

Propriétés héritage
Appel de constructeur (2/2)

// Classe de base
class Personne {
private:
string nom;
public:
Personne(string n) { nom = n }
};
// Classe dérivée
class Etudiant: public Personne {
private:
string NumEtud;
public:
Etudiant(string nom, string
NumEtud):Personne(nom),NumEtud(NumEtud)
{ }
};
 Propriétés héritage
Héritage Multiple

Remarque : en C++, une classe peut être dérivée à partir de plusieurs

classes de bases mais elle peut aussi être dérivée plusieurs fois de la
même classe de base d’une manière indirecte.
Lire : l’héritage en diamant sur
loic-joly.developpez.com/articles/heritage-multiple/.
 Notion de polymorphisme
Présentation (1/2)

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.

spécialisation
 Notion de polymorphisme
Présentation (2/2)

La notion de polymorphisme signifie que, la même opération pouvant

se comporter différemment sur différentes classes de la hiérarchie,

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.
Le polymorphisme est implémenté en C + + avec:
1. Les fonctions virtuelles (virtual)
2. L’héritage.
 Notion de polymorphisme
Exemple: Cercle /Ellipse

Ellipse La fonction affiche() n’est pas la

cX même pour une Ellipse et un Cercle.
cY
a
La redéfinition de cette fonction
b
dans chacune des sous-classes
deplace() entraînera un comportement
zoom() différent suivant qu’il s’agit d’une
surface() Ellipse ou d’un Cercle.
virtual affiche()

Cercle

affiche()

46
 Notion de polymorphisme :
Appel de méthodes
#include " cercle.h" Appelle la fonction affiche() de
la classe Ellipse.
int main()
La fonction deplace() n’est pas
{ redéfinie dans la classe Cercle,
Ellipse e(0, 0, 8.5, 10.2); appelle celle de Ellipse.
e.deplace(-1, 1);
e.affiche();

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

La fonction affiche() est redéfinie dans la
c.deplace(0.5, 1.5);
classe Cercle, appelle celle de Cercle.
c. affiche();

Ellipse *p1; Si la fonction affiche() est virtuelle et est

p1 = new Ellipse; redéfinie dans la classe Cercle, appelle
celle de Cercle bien que le pointeur soit
p1 affiche();
de type Ellipse. C'est le mécanisme de
polymorphisme d'héritage.
Ellipse *p2;
p2 = new Cercle; Si la fonction affiche() n’est pas
virtuelle, C'est la fonction de la classe
p2  affiche(); 47
Ellipse qui est appelée
return 0;
}
 Notion de polymorphisme :
Comportement non Polymorphe (1/3)
#include <iostream>
using namespace std; Implémenter les classes suivantes :
class Forme {
public:
Forme() { cout <<
"constructeur
Forme: "; }
void dessiner()
{ cout << "je
dessine ... une
forme ?\n"; }
};
class Cercle : public Forme
{ public:
Cercle() { cout << "Cercle \
n"; }
void dessiner() { cout << "je
dessine un Cercle !\n"; }
};
 Notion de polymorphisme :
Comportement non Polymorphe(2/3)

void faireQuelqueChose(Forme &f)

{
f.dessiner(); // dessine une Forme
}
int main()
{
Cercle c;
Triangle t;
faireQuelqueChose(c); // avec un
cercle
faireQuelqueChose(t); // avec un
triangle
return 0;
}Question1 Implémenter les Classes et les méthodes ci-dessus

Question2 La méthode « dessiner » de quel classe est appelée à chaque fois ?

 Notion de polymorphisme :
Comportement non Polymorphe (3/3)

L’exécution du programme d’essai nous montre que nous n’obtenons pas un

comportement polymorphe puisque c’est la méthode dessiner() de la classe
Forme qui est appelée :

Exemple : comportement non polymorphe

constructeur Forme: Cercle

constructeur Forme : Triangle
je dessine ... une forme ?
je dessine ... une forme ?
 Notion de polymorphisme :
Comportement Polymorphe (1/2)
#include <iostream>
using namespace std; Ajouter le mot « virtual » devant
Question3
class Forme { l’entête de la fonction « dessiner »
public:
Forme() { cout <<
"constructeur Forme
\n"; }
virtual void
dessiner() {
cout << "je
dessine ... une
forme ?\n";
}};
class Cercle : public
Forme{ public:
Cercle() { cout << "Cercle\n"; }
void dessiner() { cout << "je
dessine un Cercle !\n"; }
};
 Exemple :
comportement
polymorphe (2/3)
Question4 La méthode « dessiner » de quel classe est
appelée à chaque fois ?
 Notion de polymorphisme :
Comportement Polymorphe(2/2)
L’exécution du programme d’essai nous montre maintenant que nous obtenons un
comportement polymorphe puisque c’est la “bonne“ méthode dessiner() qui
est appelée :
Exemple : comportement polymorphe (3/3)

constructeur Forme : Cercle

constructeur Forme : Triangle
je dessine un Cercle !
je dessine un Triangle !

Conclusion : Le C++ permet, par le polymorphisme, que des

objets de types différents (Cercle, Triangle, ...) répondent
différemment à un même appel de fonction (dessiner()).
la méthode dessiner sera virtuelle et fournira un comportement polymorphe
 Notion de polymorphisme :
Appel de destructeur: Problème
class A {
private:
int *p;
public:
A(){ p = new int[4]; cout << L’affichage met en évidence
"A()";} un problème de "fuite" de
~A(){ mémoire. Le destructeur
delete [] p; de B n’est jamais appelé !
cout<< "~A()" << endl;
}};
class B : public A {
private:
int *q;
public:
B() { q = new int[64]; cout<<
"B() et q=" << q;}
~B(){ delete [] q; cout<< "
~B()";}
};
int main() {
A *pA = new B(); delete pA; / /
 Notion de polymorphisme :
Appel de destructeur: Solution !
class A {
private:
int *p;
public:
A(){ Avec la déclaration du
p = new int[4]; destructeur de A en
cout << "A()";} virtuel (virtual), le
virtual ~A() { destructeur de B est
delete [] p; correctement appelé.
cout<< " ~A()" << endl;}
};
class B : public A {
private:
int *q;
int main() {
public: A *pA = new B()
B() { delete pA;
q = new int[64]; / / A()B() et q=0x100170 ~B()
cout<< "B() et q=" << q;} ~A()
~B() { }
delete [] q; cout<< " ~B()";}
 Classe abstraite

Classe Abstraite en C++

Une classe est dite abstraite si elle contient au moins une

fonction 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 classe abstraite ne peut pas être instanciée : on ne peut créer
d’objet à partir d’une classe abstraite.
Il est obligatoire d’avoir une définition pour les fonctions virtuelles
pures au niveau des classes dérivées
Une classe abstraite permet d’introduire certaines fonctions
virtuelles dont on ne peut encore donner aucune définition.
 Classe Abstraite en C++
Exemple :

• Dans cet exemple, on ne sait pas programmer ce que doit

faire la fonction dessiner() dans le contexte de Forme. On
veut juste s’assurer de sa présence dans toutes les classes
filles, sans devoir la définir dans la classe parente.
/ / La classe Forme ne peut pas être instanciée : abstraite
Class Forme { public:
Forme() {}
virtual void dessiner() = 0; / / cela oblige tous
les descendants à contenir une méthode dessiner()
};

class Cercle : public Forme {

public:
Cercle() {}
void dessiner() { cout << "je
dessine un Cercle !\n"; }
};

class Triangle : public Forme

{ public:
Triangle() {}
void dessiner() { cout << "je
dessine un Triangle !\n"; }
};
 Le Transtypage en C++
Le transtypage (cast ou conversion de type) en C++ permet la conversion
d’un type vers un autre.
Nouvelle syntaxe de l’opérateur traditionnel :
En C : (nouveau type)(expression à transtyper);
En C++ : type(expression à transtyper);
Nouvel opérateur de transtypage :
static_cast : Opérateur de transtypage à tout faire. Ne permet pas de
supprimer le caractère const ou volatile.
const_cast : Opérateur spécialisé et limité au traitement des const et
volatile
dynamic_cast : Opérateur spécialisé et limité au traitement des
downcast.
reinterpret_cast : Opérateur spécialisé dans le traitement des
conversions de pointeurs peu portables.
La syntaxe est la suivante :
op_cast<expression type>(expression à transtyper); où op
prend l’une des valeurs (static, const, dynamic ou reinterpret)
 Le Transtypage en C++
Transtypage ascendant
Traiter un type dérivé comme s’il était son type de base est appelé transtypage
ascendant, surtypage ou généralisation (upcasting ). Cela ne pose donc aucun
problème.
Exemple : transtypage « ascendant »

class Forme {};

class Cercle : public Forme {};
class Triangle : public Forme
{} ;

void faireQuelqueChose(Forme &f)

{ f.dessiner(); }

...

Cercle c;

/ / Un Cercle est i c i passé à une

fonction qui attend une Forme.
/ / Comme un Cercle est une Forme, i l peut être traité comme
tel par faireQuelqueChose()
faireQuelqueChose(c);
 Le Transtypage en C++
Transtypage descendant
Conversion d’un pointeur sur un objet d’une classe générale vers un
objet d’une classe spécialisée.
Exemple : transtypage « ascendant »
class Animal { public: virtual ~Animal()
{} }; class Chien : public Animal {};
class Chat : public Animal {};

int main() {
Animal* a = new Chat; / / Transtypage
ascendant

/ / On essaye de le transtyper en Chat* :

Chat* c1 = a; / / Erreur : invalid conversion
from ’Animal*’ to ’Chat*’

Chat* c2 = dynamic_cast<Chat *>(a); / / Valide

: Transtypage descendant
}
 Vocabulaire

• Variable : associe un nom (un symbole) à une valeur qui peut éventuellement varier au cours du temps ;
une variable est d’un type donné, défini une fois pour toute (type prédéfini dans le langage ou créé par le
développeur).
• Encapsulation : regroupement des variables et des fonctions au sein d'une même entité appelée
« classe ».
• Classe : prototype qui définit des attributs et des méthodes communes à tous les objets d'une certaine
nature.
• Interface de classe : description de la structure interne de la classe incluant une liste des données
membres et le prototype des fonctions membres ; dans un « .h ».
• Implantation de classe : définition (code) des fonctions déclarées dans l’interface de classe ; dans un
« .cpp ».
• Instanciation d’un objet : permet de créer un objet d’un type donné ; analogue à une déclaration de
variable.
• Héritage : permet de définir une hiérarchie de classe, chaque classe fille héritant des méthodes et des
données de son/ses antécédent(s).
• Polymorphisme : deux objets héritant une même méthode d'une classe parente, peuvent réagir de façon
différente à l'appel de cette méthode et, à cette fin, redéfinir la méthode. Il est ensuite possible d'appeler
la méthode d'un objet sans se soucier de son type intrinsèque.

62