Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
Cours POO en C++
Les classes et les objets
Destiné aux M1 : AII
I. INTRODUCTION
La programmation permet de résoudre pas mal de problème calculatoire et
executionnel, et cela dans bon nombres de domaine.
Cette discipline se trouve utilisé de plus en plus, et confronté de ce fait à des
problèmes de plus en plus diverses et complexe, ainsi ont été développer et mis
au point différents paradigmes, facilitant le traitement des problèmes, parmi eux
la Programmation Orientée Objet (POO).
II. QU’EST-CE QUE LA POO
La Programmation Orientée Objet ou en abrégé POO est un des nombreux
paradigmes de la programmation, il s’agit d’une manière de pensée qui permet
de résoudre les problèmes en les fractionnant.
En créant des objets, nous structurons les données, en leurs donnant un
formalisme et en codifiant leur utilisation.
III. LE PRINCIPE D’ENCAPSULATION
En programmation séquentielle, classique, on utilisera des variables de bases
telles que réels, entiers, et caractères, au plus nous pourrons utiliser des tableaux
contenant un même type de variables.
Lorsqu’on a besoin de structures plus complexes, historiquement ont été utilisé
les structures qui en C permettait de regrouper des variables de différent type
dans une même entité.
Avec le C++ il y a eu la possibilité de construire une structure ayant en plus des
variables, des méthodes qui permettent de manipuler les données (les variables
de la structure), ceux-ci codifient en quelque sorte l’utilisation des données de la
structure.
Par la suite, est apparue la POO, avec son principe d’encapsulation. Ce principe a
pour but -comme son nom l’indique- d’encapsuler les données, c’est-à-dire de les
enfermer comme dans une boite noire, elles ne seront accessibles en lecture
et/ou écriture que par les fonctions appartenant à la même entité.
IV. LES CLASSES ET LES OBJETS
Dans la réalité, un objet est défini par ses caractéristiques et sa manière d’agir et
d’interagir avec son milieu extérieur. En POO un objet est un ensemble de
variables et de fonctions.
1
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
Les variables et leurs valeurs permettent de caractériser l’objet,
Les fonctions nous indiquent la minière dont l’objet interagit avec son
milieu extérieur, et comment ces caractéristiques (ses variables) peuvent
être modifiés.
Une classe est un ensemble d’objets ayant les mêmes caractéristiques et la même
façon d’interagir avec leurs milieux extérieurs, pour être plus claire prenant
l’exemple d’un ensemble de cubes :
Dans la classe CUBE : tous les cubes vont avoir une longueur L, une largeur
l, et une profondeur p, ce sont les caractéristiques des cubes, sans
précision de valeurs.
Un objet de la classe CUBE, donc un Cube x en particulier va avoir une
longueur L, une largeur l et une profondeur p propre à lui, c’est-à-dire que
L, l et p vont se voir attribuer des valeurs.
Concernant les fonctions, elles vont être identique pour tous les objets.
De manière plus concrète maintenant, et en utilisant le langage C++, voici
comment on définit une classe et comment on instancie ou déclare ses
objets.
1. Définition d’une classe :
La définition d’une classe permet d’indiquer à la machine nos besoin, c’est
dire quel type de variables va contenir notre classe, ainsi que les
prototypes des fonctions de la classe. Donc si on reprend l’exemple de la
classe CUBE, on devra écrire :
2
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
class CUBE
{ //les variables
float L;
Programme 1 : float l;
float p;
Ebauche de la classe CUBE
//les fonctions
void initialise();
void affiche();
};
Dans cette classe CUBE, il y a trois variables de type réel L, l et p, ainsi que deux prototypes
de fonctions initialise et affiche ayant « void » comme type de retour et aucun argument
d’entrée.
Il faut remarquer que la classe ainsi définit est complètement encapsulé c’est-à-dire aussi
bien les variables que les fonctions ne seront accessibles par l’extérieur. La classe ainsi
conçue n’est pas utilisables. Le programme reste n’est en moins compilable.
Afin de rectifier l’écriture de cette classe, on devra dans le respect du principe de
l’encapsulation écrire la classe CUBE comme donné dans Programme2.
Ici le mot clé « private : » appliqué aux variables permet de les encapsuler, ces dernières ne
seront visibles que par les fonctions de la classe.
Et le mot clé « public : » appliqué aux fonctions permet d’appeler les fonctions de l’extérieur
de la classe.
class CUBE
{ //les variables
privates :
float L; Programme 2 :
float l;
float p; Principe d’encapsulation
//les fonctions
public :
void initialise();
void affiche();
};
3
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
2. Le constructeur :
Le constructeur est une fonction particulière propre à une classe, elle
permet d’initialiser les objets de cette classe, en donnant des valeurs à ces
variables.
Le constructeur doit impérativement avoir le même nom que la classe, et
ne doit pas avoir de type de retour.
3. Définition des fonctions de la classe :
La définition des fonctions revient à décrire le fonctionnement de ces
dernières, en indiquant leurs variables locales et les instructions
nécessaires à leurs bons fonctionnements.
Ainsi les définitions des fonctions de la classe CUBE sont données par :
void CUBE::initialise()
cout<<"donner la longueur du cube :"; cin>> L;
cout<<"donner la largeur du cube :"; cin>>l;
cout<<"donner la profondeur du cube :"; cin>>p;
void CUBE::affiche()
cout<<"les dimensions du cube sont
(L,l,p)=("<<L<<","<<l<<","<<p<<")\n";
Les instructions void CUBE::initialise() et void CUBE::affiche(), sont constituées du mot clé
void qui indique que ces deux fonctions n’ont pas de valeur de retour, CUBE indique que
ces fonctions appartiennent à la classe CUBE, les deux points ( :: ) est l’opérateur de portée,
il est suivi du nom de la fonction et ces arguments d’entrée si elle en a.
Cas particulier du constructeur :
Si dans une classe, on ne définit pas de constructeur, la machine définit un
constructeur par défaut, qui donnera lors de l’instanciation d’un objet, des
valeurs par défaut (aléatoires ) à ces variables.
Il est aussi important d’indiquer, que dans une classe, on peut avoir
plusieurs constructeur, différent par leurs prototypes.
4
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
4. Déclaration ou Instanciation d’un objet :
Instancier un objet d’une classe, revient à déclarer un objet, c’est-à-dire
réserver un espace mémoire à toutes les variables de l’objet et de les
initialiser.
Ainsi, si l’instanciation d’un objet de la classe CUBE, se fait par
l’instruction :
CUBE X1,X2 ;
Où CUBE est évidemment le nom de la classe, et X1 et X2, sont les noms des
objets instancier.
Ici, il n’y a pas de constructeur définit pour cette classe, ainsi les variables auront
des valeurs par défaut.
5. Appel d’une fonction de la classe : pour appeler un fonction de la classe, il
faut avoir déclarer un objet de cette classe au préalable. De manière
générale cet appel se fait comme suit :
Nom_Objet.nom_fonction(arg_ fonction) ;
Pour le cas de notre classe CUBE :
Déclarer un objet : CUBE X1 ;
Appeler la fonction initialise() : X1.initialise() ;
Appeler la fonction affiche() : X1.affiche() ;
V. Les getters et les setters
V.1 Les getters :
Les getters, du verbe anglais « to get », qui signifie en français « avoir » ou
« obtenir », on utilisera aussi le terme accesseurs. Sont des fonctions qui
permettent de lire les valeurs des variables, qui sont encapsulées par principe
dans une classe.
Un getter doit :
Avoir comme type de retour le type de la variable qu’il lit ;
En générale, n’a pas d’argument d’entrée ;
Par convention, son nom est de la forme « get_NomVariable », où get
permet de faciliter l’identification de sa fonction parmi les différentes
fonctions de la classe, et NomVariable permet d’identifier quelle variable
de la classe est lu ;
De manière générale un getter s’écrira comme suit :
5
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
typeVariable get_NomVariable()
{
Return NomVariable ;
}
V .2 Les setters :
Les setters, du verbe anglais « to set » qui signifie en français « poser » ou
« fixer », on utilisera aussi le terme mutateurs. Sont des fonctions qui permettent
de modifier les valeurs des variables, qui sont par principe encapsulées dans une
classe.
Un setter doit :
Avoir comme type de retour void, car il modifie une variable de la classe
dont il fait partie, cette variable et donc déjà déclarer et son espace
mémoire réservé ;
Avoir comme argument d’entée une variable du même type que la
variable qu’il modifie ;
Par convention, son nom est de la forme « set_NomVariable », où set
permet de faciliter l’identification de sa fonction parmi les différentes
fonctions de la classe, et NomVariable permet d’identifier quelle variable
de la classe est modifié ;
De manière générale, un setter s’écrire comme suit :
void set_NomVariable(typeVariable variable)
{
NomVariable=variable ;
}
En considérant, toutes ces informations, on peut écrire la classe CUBE comme
indiquer dans ce qui suit.
La classe CUBE complète :
#include <iostream>
using namespace std;
class CUBE
{
private:
float L;
float l;
float p;
6
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
public:
CUBE();//premier constructeur où les valeurs des variables
seront données de manière aléatoire par la machine.
CUBE(float , float , float );// deuxième constructeur où les
valeurs devront être donner lors de la déclaration de l’objet.
CUBE(float, float );//ici la profondeur n'est pas initialisée
void initialise();
void affiche();
float get_L();
float get_l();
void set_p(float);
};
CUBE::CUBE()
{
L=0;
l=0;
p=0;
}
CUBE::CUBE(float a,float b,float c)
{
L=a;l=b;p=c;
}
CUBE::CUBE(float d, float e)
{
L=d; l=e;
}
float CUBE::get_L()
{
return L;
}
float CUBE::get_l()
{
return l;
}
void CUBE::set_p(float s)
{
p=s;
}
void CUBE::initialise()
{
cout<<"donner la longueur du cube :"; cin>> L;
cout<<"donner la largeur du cube :"; cin>>l;
cout<<"donner la profondeur du cube :"; cin>>p;
}
void CUBE::affiche()
{
cout<<"les dimensions du cube sont
(L,l,p)=("<<L<<","<<l<<","<<p<<")\n";
}
int main()// ceci ne fait évidemment pas partie de la classe, mais
permet de tester son bon fonctionnement
{
7
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
CUBE X1;//X1 est un objet de la classe CUBE, déclarer en
utilisant le 1er constructuer.
CUBE X2(1,2,3);//X2 est un 2ème objet déclarer en utilisant le
2ème constructeur, ici des valeur sont données à L,I et p.
CUBE X3 (4,5);// X3 est un 3ème Objet déclarer avec le 3ème
constructeur où seul p n’a pas de valeur donnée par l’utilisateur,
la machine lui attibura un valeur alèatoire.
cout<<"effet des differents constructeurs :\n";
cout<<"constructeur par defaut \n";
X1.affiche();
cout<<"constructeurs où L,l, et p sont initialisées \n";
X2.affiche();
cout<<"constructeur où p n'est pas initialisée\n";
X3.affiche();
cout<<"test des getters et getters\n";
cout<<"get_L de X1\n";
cout<<"X1.L="<<X1.get_L()<<endl;
cout<<"get_l de X2 \n";
cout<<"X2.l="<<X2.get_l()<<endl;
cout<<"set_p de X3 \n";
X3.set_p(6);
cout<<"X3 :"; X3.affiche();
return 0;
}
Le résultat est le suivant :
8
Cours POO en C++ Les classes et les objets
M1 : AII
Mme AMIROUCHE USDB
