CU Tipaza Chapitre 3. Classes et objets P.O.

1. La notion de classe en POO

Une classe permet de regrouper dans une même entité des données et des fonctions
membres (appelées aussi méthodes) permettant de manipuler ces données. La classe est la
notion de base de la programmation orientée objet. Un objet est un élément d'une certaine
classe : on parle de l'instance d'une classe.
2. Déclaration de classe
Pour déclarer une classe, il suffit :
- De mettre le mot clé class ;
- De préciser quels sont les membres publics (fonctions ou données) et les membres
privés en utilisant les mots clés public et private.
Exemple 1: on va déclarer une class Point dans laquelle tous les membres données sont
privés, et toutes les fonctions membres sont publiques. Sa déclaration serait simplement la
suivante :

/* ------------ Déclaration de la classe point ------------- */

class point
{ /* déclaration des membres privés */
private :
int x ;
int y ;
/* déclaration des membres publics */
public :
void initialise (int, int) ;
void affiche () ;
};

Ici, les membres nommés x et y sont privés, tandis que les fonctions membres nommées
initialise, deplace et affiche sont publiques.

3. Définition des méthodes

En ce qui concerne la définition des fonctions membres d’une classe, l’exemple suivant
montre comment elle sera faite :

Master 1 électronique / Instrumentation 1

CU Tipaza Chapitre 3. Classes et objets P.O.O

#include <iostream>
using namespace std ;
/* ------------ Déclaration de la classe point ------------- */
class point
{ /* déclaration des membres privés */
private :
int x ;
int y ;
/* déclaration des membres publics */
public :
void initialise (int, int) ;
void affiche () ;
};
/* ----- Définition des fonctions membres de la classe point ---- */
void point::initialise (int abs, int ord)
{ x = abs ; y = ord ;
}
void point::affiche ()
{ cout << "Je suis en " << x << " " << y << "\n" ;
}
/* -------- Utilisation de la classe point -------- */

main()

point a, b ; /* on dit que a et b sont des instances de la classe point */

/* ou encore que ce sont des objets de type point ; */

a.initialise (5, 2) ; a.affiche () ;

b.initialise (1,-1) ; b.affiche () ;

Master 1 électronique / Instrumentation 2

CU Tipaza Chapitre 3. Classes et objets P.O.O

4. Droits d’accès et encapsulation

L’encapsulation est un processus consistant à combiner des membres de données et des
fonctions dans une seule unité appelée classe. Afin d’empêcher l’accès aux données
directement, l’accès aux données est fourni via les fonctions de classe. C’est l’une des
fonctionnalités populaires de la programmation orientée objet (POO) qui aide à la
dissimulation des données.
Il y a trois droits d'accès à connaître :
 public : tout le monde peut accéder à l'élément ;
 private : accessible uniquement aux fonctions membres de la même classe ;
 protected : identique à private : accessible aux fonctions membres de la classe
mais aussi aux fonctions membres des classes dérivées.
Exemple :

class test1{
private:
int a;
void meth1();
protected:
int b;
void meth2();
public:
char c;
void meth3();
};
class test2 : public test1{
public:
void meth4();
};
//...
test1 x;
test2 y;

Pour cet exemple, on aura:

 x.a, x.b, x.meth1() et x.meth2() qui seront interdits

 meth1, meth2, meth3 auront accès à tout : a, meth1(), b, meth2(), c, meth3()
 x.c, x. meth3() seront accessibles à tous.
 test1:: meth4() aura accès à : b, meth2(), c, meth3()
 test1:: meth4() n'aura pas accès à : a, meth1()

Master 1 électronique / Instrumentation 3

CU Tipaza Chapitre 3. Classes et objets P.O.O

5. Séparations prototypes et définitions

Jusqu'ici, nous n'avions qu'un seul fichier source dans notre projet. Ce fichier source,
je vous avais demandé de l'appeler main.cpp. On va maintenant apprendre comment
séparer son code en plusieurs fichiers, ce qui va nous permettre de mieux l’organiser.
Les classes C ++ (et souvent les prototypes de fonctions) sont normalement divisées
en deux fichiers. Le fichier d'en-tête a l'extension .h et contient les définitions de classe et
les fonctions. L'implémentation de la classe va dans le fichier .cpp.
Un fichier avec extension .h (pour header file ou fichier d’en-tête en français) est un
fichier l’où on peut mettre les prototypes de tes sous-programmes en C++ et d’autres
composants pouvant être utile.
Le fichier doit débuter comme ceci :
#ifndef nom_du_fichier_h
#define nom_du_fichier_h

Et se terminer comme ceci : #endif

On peut ensuite l’intégrer au fichier .cpp en écrivant :
#include "nom_du_fichier.h"
Example :
Fichier point.h Fichier point.cpp
#ifndef Point_H #include <iostream>
#define Point_H #include "point.h"
class point using namespace std;
{ void point::initialise (int abs, int ord)
private : { x = abs ; y = ord ;
int x, y ; }
public : void point::affiche ()
void initialise (int, int) ; { cout << "Je suis en " << x << " " << y << "\n" ;
void affiche () ; }
};
#endif
Fichier main.cpp
#include "point.h"
main()
{
point a, b ;
a.initialise (5, 2) ; a.affiche () ;
b.initialise (1,-1) ; b.affiche () ;
}

Master 1 électronique / Instrumentation 4

CU Tipaza Chapitre 3. Classes et objets P.O.O

Ceci dit si “Point_H” n'est pas défini, alors définissez-le. Par conséquent, les tentatives
ultérieures de lecture de cette classe entraînent l’omission de la définition car Point_H est
déjà défini. Si nous ajoutons ceci à notre classe point.h, il sera maintenant compilé et
exécuté.
On peut utiliser n'importe quel nom, mais il est recommandé d'utiliser un nom associé
à la classe.

6. Constructeur et destructeur
 Les données membres d'une classe ne peuvent pas être initialisées durant leur
définition. Il faut donc prévoir une méthode d'initialisation de celles-ci.
 De même, après avoir fini d'utiliser un objet, il est bon de prévoir une méthode
permettant de détruire l'objet (libération de la mémoire dynamique ...).
Le constructeur est une fonction membre spécifique de la classe qui est appelée
implicitement à l'instanciation de l'objet, assurant ainsi une initialisation correcte de
l'objet. Le constructeur est une fonction qui porte comme nom, le nom de la classe et qui
ne retourne pas de valeur (pas même un void).
De la même façon que pour le constructeur, le destructeur est une fonction membre
spécifique de la classe qui est appelée implicitement à la destruction de l'objet.
On appelle constructeur par défaut un constructeur n'ayant pas de paramètres ou ayant
des valeurs par défaut pour tous les paramètres.
Le destructeur est une fonction: • qui porte comme nom, le nom de la classe précédé
du caractère ~ (tilde), • qui ne retourne pas de valeur (pas même un void), • qui n'accepte
aucun paramètre (le destructeur ne peut donc pas être surchargé).

class personne {
private:
int age;
public:
personne (int); //constructeur
~personne(); //destructeur
};
personne::personne(int a) { //constructeur
age=a;
}
personne:: ~personne() { //destructeur
}

7. Les méthodes constantes

Certaines méthodes d'une classe ne doivent (ou ne peuvent) pas modifier les valeurs des
données membres de la classe, ni retourner une référence non constante ou un pointeur
non constant d'une donnée membre : on dit que ce sont des fonctions membres constantes.
Ce type de déclaration renforce les contrôles effectués par le compilateur et permet donc
une programmation plus sûre. Il est donc très souhaitable d'en déclarer aussi souvent que
possible dans les classes.

Master 1 électronique / Instrumentation 5

CU Tipaza Chapitre 3. Classes et objets P.O.O

class point {

int x, y ;

public : point (...) ;

void afficher () const ;

void initialiser (...) ;

};

8. Classes et pointeurs
En C++, il existe deux façons de créer des objets, c'est-à-dire d'instancier une classe :
 de façon statique
 de façon dynamique
La création statique
La création statique d'objets consiste à créer un objet en lui affectant un nom, de la même
façon qu'avec une variable :
Nom_de_la_classe Nom_de_l_objet ;
Ainsi, l'objet est accessible grâce à son nom.
La création dynamique
La création dynamique d'objet est une création d'objet par le programme lui-même en
fonction de ses « besoins » en objets. Les objets ainsi créés ne peuvent pas avoir de nom
permettant de les manipuler facilement, les objets créés dynamiquement sont donc repérés
par des pointeurs.
La création d'objet dynamique se fait donc par la procédure suivante :
 définition d'un pointeur vers une classe donnée (celle dont va être instancié l'objet
créé dynamiquement).
 création de l'objet « dynamique » grâce au mot clé new, renvoyant l'adresse de
l'objet nouvellement créé.
 affecter cette adresse au pointeur.
Voici donc ce à quoi peut ressemblé une création d'objet dynamique en C++ :
Nom_de_la_classe * Nom_du_pointeur;

Nom_du_pointeur = new Nom_de_la_classe;

Point * p ;

p = new Point ;

delete p;

Master 1 électronique / Instrumentation 6

CU Tipaza Chapitre 3. Classes et objets P.O.O

Grâce à ce pointeur il va désormais être possible de manipuler l'objet « dynamique »,

c'est-à-dire accéder à ses fonctions membres et/ou ses données membres.

Tout objet créé dynamiquement, c'est-à-dire avec le mot-clé new devra impérativement
être détruit à la fin de son utilisation grâce au mot clé delete. Dans le cas contraire, une
partie de la mémoire (celle utilisée par les objets créés dynamiquement) ne sera pas
libérée à la fin de l'exécution du programme.
Les objets créés de façon statique n'ont pas besoin d'être détruits, ils sont
automatiquement supprimés lorsque le programme ne fonctionne plus dans la portée
dans laquelle ils ont été définis.

Le mot clé delete s'utilise en le faisant succéder du pointeur vers l'objet à supprimer. Suite
à la suppression d'un objet, la mémoire qu'il occupait est libérée. Il faut alors affecter la
valeur NULL à son pointeur.
Accéder aux données membres d'un objet
L'accès aux données membres d'un objet se fait différemment selon que l'objet a été créé
de façon statique ou dynamiquement :
 Pour les objets créés statiquement, l'accès aux données membres se fait grâce au
nom de l'objet, suivi d'un point (.), puis du nom de la donnée membre. Par
exemple :
Nom_de_l_objet.Nom_de_la_donnee_membre = Valeur;
 Pour les objets créés dynamiquement, l'accès aux données membres se fait grâce
au nom du pointeur vers l'objet, suivi d'une flèche point (->) représentée par un
moins (-) et un signe supérieur (>), puis du nom de la donnée membre. Par
exemple :
Nom_du_pointeur->Nom_de_la_donnee_membre = Valeur;
p->x=a ;
Accéder aux fonctions membres d'un objet
L'accès aux fonctions membres d'un objet se fait comme pour l'accès aux données
membres, c'est-à-dire par un point ou une flèche selon la création de l'objet. La fonction
membre est suivie de parenthèses, contenant les paramètres, s'il y en a. L'accès à une
fonction membre se fait donc de la façon suivante :
 En statique :
Nom_de_l_objet.Nom_de_la_fonction_membre(parametre1,parametre2,...);
 En dynamique :
Nom_du_pointeur->Nom_de_la_fonction_membre(parametre1,parametre2,...);
p-> initialise(5, 2)
Le pointeur courant this

Master 1 électronique / Instrumentation 7

CU Tipaza Chapitre 3. Classes et objets P.O.O

Le mot clé this permet de désigner l'objet dans lequel on se trouve, c'est-à-dire que lorsque
l'on désire faire référence dans une fonction membre à l'objet dans lequel elle se trouve, on
utilise this.
L'objet courant this est en réalité une variable système qui permet de désigner l'objet
courant. Cette variable est passée en tant que paramètre caché de chaque fonction
membre.
Ainsi, lorsque l'on désire accéder à une donnée membre d'un objet à partir d'une fonction
membre du même objet, il suffit de faire précéder le nom de la donnée membre par this->.
Par exemple :

class personne {
private:
int age;
float taille;
public:
personne (int, float); //constructeur
~personne(); //destructeur
};
personne::personne(int age, float taille) {
this->age=age;
this->taille=taille;
}
personne:: ~personne() { //destructeur
}

Master 1 électronique / Instrumentation 8