UMMTO, Masters1 Académiques

Programmation Orientée Objets en C++ (UEM1.1)

Chapitre 3 : Classes, Objets et encapsulation

-> Déclaration de classe en C++
Pour commencer, une classe est constituée :
● de variables, ici appelées attributs (on parle aussi de variables membres) ;
de fonctions, ici appelées méthodes (on parle aussi de fonctions membres).
Code minimal pour créer une classe :
class A
{
…...
};

Exemple : définition d’une classe Point définissant un point de coordonnées x, y et de couleur c.

class Point {
// déclaration des attributs d’un point coordonnées x, y et couleur
int m_x;
int m_y;
int m_c;
// déclaration des constructeurs et destructeurs
Point() {m_x=0; m_y=0}; // constructeur
Point(int, int, int); // constructeur avec initialisation
~Point(); // destructeur
// déclaration des méthodes notamment les get et set
int get_x(void);
int get_y(void);
int get_color(void);
void set_x(int);
void set_y(int);
void set_color(int);
void move(int, int); // méthode de déplacement du point
};
Remarque : prendre l’habitude de commencer le nom des classes par une majuscule pour les
différencier des noms d’objets.
Les services getAttribut() et setAttribut() sont appelées des méthodes modificateurs et méthodes
accesseurs : getters et setters.

➔ Définition des méthodes :

La définition des méthodes peut se faire à plusieurs niveaux :
 dans la définition de la classe elle-même (comme par exemple get_x() dans l’exemple
précédent),
en dehors de la classe, on utilisera alors l’opérateur de résolution de porté ::

void Point::move(int x, int y){

m_x=x;
m_y=y;
}

1/4
UMMTO, Masters1 Académiques
Programmation Orientée Objets en C++ (UEM1.1)

➔ Utilisation de la classe :
L’accès aux composants de la classe courante se fait directement par le nom du composant (attribut
ou méthode).

Point p; // déclaration d’un point p dans ce cas c’est le constructeur Point() qui sera appelé
Point q(10, 20, 120); // déclaration d’un point q avec initialisation, dans ce cas, c’est le constructeur
// Point(int, int, int) qui sera appelé
Point *u; // Déclaration d’un pointeur sur un point
cout << p.get_x(); // affiche la coordonnée x du point p
cout << p.m_y; // affiche la coordonnée y de p si elle est publique
q.set_y(120); // change la coordonnée y du point q en 120
p.move(15, 25); // déplace le point p aux coordonnées x=15 et y=25
u=new Point; // Allocation mémoire pour le point u
u->set_x=125; // exécution de la méthode set_x pour le point u. Ici on utilise -> au lieu du .
cout << u->get_x(); // affichage de la coordonnée x du point u

-> Droits d'accès et encapsulation,

En C++, il y a trois niveaux de visibilité :
- public : les composants publics sont accessibles par toutes les méthodes ou classes ;
- private : les composants privés ne sont accessibles que par des méthodes de la classe ;
- protected : les composants protégés ne sont accessibles que par des méthodes de la classe ou
des classes héritant de la classe.
On fixe le niveau de visibilité en l’écrivant sur une ligne suivi de :.
Tous les composants déclarés ensuite auront cette visibilité jusqu’à la prochaine spécification.
Par défaut les composants sont privés.
class Point {
// Encapsulation des attributs
private :
int m_x;
int m_y;
int m_c;
….
}

➔ Séparations prototypes et définitions,

En cas de compilation séparée (recommandée, surtout en programmation objet !) la déclaration de
la classe, se trouve dans un fichier entête (exemple point.h) et les définitions dans un fichier de
code (point.cpp pour la classe point)
Si on définit une méthode dans une classe, le compilateur la considère inline.

➔ Constructeur et destructeur,
Si aucun constructeur n’est spécifié, on utilise lors de la création de l’objet un constructeur par
défaut sans argument, qui ne fait rien. Dès lors qu’un constructeur est spécifié, ce constructeur par
défaut n’existe plus.

2/4
UMMTO, Masters1 Académiques
Programmation Orientée Objets en C++ (UEM1.1)

Comme une méthode, le constructeur est normalement seulement déclaré dans la classe et défini en
dehors.
Point::Point(int x, int y, int color ){
m_x = x; m_y = y; m_color = color;
}
Comme pour une fonction ou une méthode, le constructeur peut avoir des valeurs par défaut pour
certains de ces éléments.
 Constructeur par recopie : À chaque fois qu’un objet est dupliqué (passage par valeur dans une
fonction par exemple), un constructeur par copie est appelé.
Si celui-ci n’est pas explicitement défini, l’action du constructeur par défaut consiste à copier la
valeur des attributs. On peut redéfinir ce constructeur ; il s’agit d’un constructeur qui prend en
paramètre une référence constante d’un objet du type courant :
Point(const Point&);

Attention, si ce constructeur est explicitement défini, il faut explicitement définir la copie des
valeurs des attributs qui ne se fait plus toute seule.
Pour créer un objet par recopie, il suffit de faire passer en paramètre un objet à la déclaration de
l’objet à créer :
Point p(12, 55, 10);
Point z(p): // z aura les mêmes valeurs que le point p
 Destructeur : À chaque fois qu’un objet est détruit (fin de vie d’une variable automatique, dés-
allocation explicite), un destructeur de l’objet est appelé. Par défaut, ce destructeur détruit
seulement l’objet et non les objets associés.
On peut redéfinir ce destructeur. Il n’a aucun argument, aucun type de retour ; il porte le nom de la
classe précédé d’un tilde ~ : exemple :
~Point();

3/4
UMMTO, Masters1 Académiques
Programmation Orientée Objets en C++ (UEM1.1)

Semestre : 1
Unité d’enseignement : UEM 1.1
Matière 4 : Programmation orientée objets en C++
VHS : 37h30 (Cours : 1h30, TP : 1h00)
Crédits : 3
Coefficient : 2
Objectifs de l’enseignement :
L’étudiant va devoir apprendre à partir de cette matière les fondements de base de la
programmation orientée objets ainsi que la maitrise des techniques de conception des
programmes avancés en langage C++.
Connaissances préalables recommandées :
Programmation en langage C.
Contenu de la matière :
Chapitre 1. Introduction à la programmation orientée objets (POO) (2 semaines)
Principe de la POO, Définition du langage C++, Mise en route de langage C++, Le noyau C du langage C+
+.
Chapitre 2. Notions de base (2 semaines)
Les structures de contrôle, Les fonctions, Les tableaux, La récursivité, Les fichiers, Pointeurs, Pointeurs
et références, Pointeurs et tableaux, L'allocation dynamique.
Chapitre 3. Classes et objets (3 semaines)
Déclaration de classe, Variables et méthodes d'instance, Définition des méthodes, Droits d'accès et
encapsulation, Séparations prototypes et définitions, Constructeur et destructeur, Les méthodes
constantes, Association des classes entre-elles, classes et pointeurs.
Chapitre 4. Héritage et polymorphisme (3 semaines)
Héritage, Règles d'héritage, Chaînage des constructeurs, Classes de base, Préprocesseur et directives
de compilation, Polymorphisme, Règles à suivre, Méthodes et classes abstraites, Interfaces,
Traitements uniformes, Tableaux dynamiques, Chaînage des méthodes, Implémentation des méthodes
virtuelles, Classes imbriquées.
Chapitre 5. Les conteneurs, itérateurs et foncteurs (3 semaines)
Les séquences et leurs adaptateurs, Les tables associatives, Choix du bon conteneur, Itérateurs : des
pointeurs boostés, La pleine puissance des list et map, Foncteur : la version objet des fonctions, Fusion
des deux concepts.
Chapitre 6. Notions avancées (2 semaines)
La gestion des exceptions, Les exceptions standard, Les assertions, Les fonctions templates, La
spécialisation, Les classes templates.

TP Programmation orientée objets en C++

- TP1 : Maitrise d’un compilateur C++
- TP2 : Programmation C++
- TP3 : Classes et objets
- TP4 : Héritage et polymorphisme
- TP5 : Gestion mémoire
- TP6 : Templates
Mode d’évaluation :
Contrôle continu : 40% ; Examen : 60%.
Références bibliographiques:
1. Bjarne Stroustrup (auteur du C++), Le langage C++, Pearson.
2. Claude Delannoy, Programmer en langage C++, 2000.
3. Bjarne Stroustrup, Le Langage C++, Édition Addison -W l (2000) Wesley (2000) ou Pearson Education France
(2007).
4. P.N. Lapointe, Pont entre C et C++ (2ème Édition), Vuibert, Edition 2001.

4/4