1

CHAPITRE 3:
CLASSES ET OBJETS

1
 DÉCLARATION DE CLASSE EN C++

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
{

}; 2 2
DÉCLARATION DE CLASSE EN C++
Exemple : définition d’une classe Point de coordonnées x,y et de
couleur c.
class Point {
int m_x; // déclaration des attributs d’un point
int m_y; // coordonnées x, y et couleur
int m_c ;
// 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); 3 3
void move(int, int); // méthode de déplacement du point
};
DÉCLARATION DE CLASSE EN C++

Remarques :
→ 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
accesseurs (accessors) : getters et setters.

4 4
DÉFINITION DES MÉTHODES

La définition des méthodes peut se faire à plusieurs niveau:

→ dans la définition de la classe elle même
→ en dehors de la classe, et notamment dans un fichier
différent, on utilisera alors l’opérateur de résolution de
porté ::
Définition des méthodes de la classe point
int Point::get_x(){
return m_x;
}
int Point::get_y(){
return m_y; 5 5

}
DÉFINITION DES MÉTHODES

void Point::set_x(int x){

m_x=x;
}
void Point::set_y(int y){
m_y=y;
}
void Point::move(int x, int y){
m_x=x;
m_y=y;
}
6 6
 CONSTRUCTEURS ET DESTRUCTEUR

●
Une classe peut avoir un ou plusieurs constructeurs : méthode(s) appelée(s)
automatique à la création des objets par cette classe.
●
Les constructeurs ont le même nom que la classe
●
Une classe a un seul destructeur : méthode appelée automatique à la
destruction des objets crées par cette classe.
●
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
et a le même nom que la classe précédé d’un tilde ~
●
Si aucun constructeur n’est spécifié, on utilise lors de la création de l’objet le
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.
7
Comme une méthode, le constructeur est normalement déclaré dans la classe
7
●

et défini en dehors.
 EXEMPLES DE CONSTRUCTEURS ET DESTRUCTEUR POUR LA CLASSE
POINT

// Constructeurs
Point::Point() {m_x=0; m_y=0};

// Constructeur avec initialisation

Point::Point(int x, int y, int color ){
m_x=x; m_y=y; m_c=color;
}

// destructeur
Point::~Point() {}; 8 8
 CONSTRUCTEUR PAR RECOPIE

→ À chaque fois qu’un objet est dupliqué 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&);
si ce constructeur est explicitement défini, il faut explicitement définir
9 9
la copie des valeurs des attributs qui ne se fait plus toute seule.
UTILISATION DE LA CLASSE
Accès aux composants de la classe courante se fait directement par le
nom du composant (attribut ou méthode) comme pour les structures.

Point p; // déclaration d’un point p : appel du constructeur Point()

Point q(10, 20, 120); // déclaration d’un point q avec initialisation,
// ici appel du constructeur Point(int, int, int)
p.set_x(25); // modification de la coordonnée x du point p
cout << p.get_x(); // affiche la coordonnée x du point p

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
10 10
UTILISATION DE LA CLASSE
Utilisation de pointeurs

Point *u; // Déclaration d’un pointeur sur un point u

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

11 11
DROITS D'ACCÈS ET ENCAPSULATION
→ En C++, il y a trois niveaux de visibilité:
public : les composants publics sont accessibles par toutes les
fonctions 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.
12 12
DROITS D'ACCÈS ET ENCAPSULATION
class Point {
private : // déclaration des attributs en private
int m_x, m_y, 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
public : // déclaration des méthodes publiques
int get_x(void); Dans ce cas de figure, il est impossible d’accéder
int get_y(void); de manière directe aux attributs :
int get_color(void); Par Exemple :
void set_x(int); p.m_x=35 ;
void set_y(int);
void set_color(int); 13
13
void move(int, int); // méthode de déplacement du point
};
SÉPARATIONS PROTOTYPES ET DÉFINITIONS,

●
La déclaration de la classe, se trouve dans un fichier entête
(exemple point.h pour la classe Point)
●
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.

14 14