Vous êtes sur la page 1sur 41

Dr Pélagie HOUNGUE

 Classes et Objets
 Définition
 Déclaration
 Exemples
 Membres statiques
 Compilation multifichier
 Classes imbriquées
 TD

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 2


 La Programmation Orientée Objet (POO) met
dans une même structure les données et les
opérations qui leurs sont associées.
 Le concept de classe correspond simplement à
la généralisation de la notion de type (par
exemple des types structurés) que l’on
rencontre dans les langages classiques.
 En effet, une classe n’est rien d’autre que la
description d’un ensemble d’objets ayant une
structure de données commune et disposant des
mêmes méthodes.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 3


Une classe chien
Plusieurs objets Chien

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 4


 Les langages « orientés objet » ont été développés
pour faciliter l’écriture et améliorer la qualité des
logiciels en termes de modularité et surtout de
réutilisation.
 Quelques avantages
 l’exactitude : réponse aux spécifications
 la robustesse : réaction correcte à une
utilisation « hors normes »
 l’extensibilité : aptitude à l’évolution
 la réutilisabilité : utilisation de modules
 la portabilité : support d’une autre
implémentation
 l’efficience : performance en termes de
vitesse d’exécution et de consommation
mémoire
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 5
 Les objets apparaissent comme des variables
d’un type donné de classe.
 En P.O.O., on dit aussi qu’un objet est une
instance de sa classe
 Seule la structure est commune,
 les méthodes sont effectivement communes à l’ensemble
des objets d’une même classe.
 En revanche, les valeurs des champs sont propres à
chaque objet.
 Toute entité identifiable, concrète ou abstraite,
peut être considérée comme un objet
 Un objet réagit à certains messages qu’on lui
envoie
 la façon dont il réagit détermine le comportement de
l’objet

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 6


 Considérons une déclaration classique de structure
telle que : struct point
{
int x ;
int y ;
};

 C++ nous permet de lui associer des méthodes


(fonctions membres)
 Supposons, par exemple, que nous souhaitions
introduire trois fonctions nommées :
 initialise pour attribuer des valeurs aux « coordonnées »
d’un point ;
 deplace pour modifier les coordonnées d’un point ;
 affiche pour afficher un point
 nous nous contenterons, d’afficher les coordonnées du point.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 7


 On pourra donc obtenir la déclaration suivante
de la structure contenant les fonctions membres
 Juste la déclaration des fonctions membres
 Les définitions peuvent être données par la suite en
dehors de la structure
struct point
{ /* déclaration "classique" des données */
int x ;
int y ;
/* déclaration des fonctions membre (méthodes) */
void initialise (int, int) ;
void deplace (int, int) ;
void affiche () ;
};

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 8


 En C++, la structure est un cas particulier de
classe.
 Plus précisément, une classe sera une structure dans
laquelle seulement certains membres et/ou fonctions
membres seront « publics »,
 c’est-à-dire accessibles « de l’extérieur »,
 les autres membres étant dits « privés ».
 La déclaration d’une classe est voisine de celle
d’une structure.
 il suffira de :
 remplacer le mot clé struct par le mot clé class ;
 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.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 9


class point
{
/* déclaration des membres privés */
private :
int x ;
int y ;

/* déclaration des fonctions membres publics */


public :
void initialise (int, int) ;
void deplace (int, int) ;
void affiche () ;
};

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 10


 Ici, les membres nommés x et y sont privés
 Ceci signifie que l’on ne peut les manipuler qu’à
travers les fonctions membres publiques.
 On dit que le langage C++ réalise l’encapsulation des
données.
 Tandis que les fonctions membres nommées
initialise, deplace et affiche sont publiques.
 Les mots-clés public et private peuvent
apparaître à plusieurs reprises dans la définition
d’une classe.
 Si aucun mot-clé n’est spécifié, alors les
membres ou les fonctions concernés sont privés.
 Les fonctions privées par exemple, ne seront
utilisables que par d’autres fonctions membres.
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 11
 Il existe un troisième niveau de visibilité,
nommé protected (protégé), qui s’utilise de
la même manière que les deux autres ;
 il sert à définir un statut intermédiaire entre
public et privé, lequel n’intervient que dans le
cas des classes dérivées.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 12


void point::initialise (int abs, int ord)
{
x = abs ;
y = ord ;
}
void point::deplace (int dx, int dy)
{
x = x + dx ;
y = y + dy ;
}
void point::affiche()
{
cout << "Je suis en " << x << " " << y << "\n" ;
}
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 13
main()
{
point a, b ; //a et b sont des instances de la classe point, ou
//encore des objets de type point
a.initialise (5, 2) ;
a.affiche () ;
a.deplace (-2, 4) ;
a.affiche () ;
b.initialise (1,-1) ;
b.affiche () ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 14


 Elle correspond à une recopie des valeurs des
membres données, que ceux-ci soient publics ou non.
 Considérons la classe suivante :
class point
{
int x ;
public :
int y ;
....
};
 point a, b ;
 On peut tout à fait écrire : b = a ;
 Mais, on ne peut pas écrire :
 b.x = a.x ; //x étant privé
 On peut par contre écrire :
 b.y = a.y ;
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 15
 Les objets suivent les règles habituelles concernant
leur initialisation par défaut :
 En général, il est donc nécessaire de faire appel à une
fonction membre pour attribuer des valeurs aux données
d’un objet.
 C’est ce que nous avons fait pour notre classe point avec
la fonction initialise.
 Contraintes
 L’utilisateur de l’objet doit effectuer l’appel de la
fonction d’initialisation au bon moment.
 cas où, avant même d’être utilisé, un objet doit
effectuer un certain nombre d’opérations nécessaires à
son bon fonctionnement
 par exemple
 allocation dynamique,
 vérification d’existence de fichier ou ouverture,
 ….

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 16


 C++ offre un mécanisme très performant pour
traiter ces problèmes : le constructeur
 Définition
 C’est une fonction membre (définie comme
les autres fonctions membres) qui sera
appelée automatiquement à chaque création
d’un objet.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 17


 Un objet pourra aussi posséder un destructeur
 c’est-à-dire une fonction membre appelée
automatiquement au moment de la destruction de
l’objet.
 Par convention, le constructeur se reconnaît à
ce qu’il porte le même nom que la classe.
 Quant au destructeur, il porte le même nom
que la classe, précédé d’un tilde (~).

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 18


 Déclaration
d’une classe (point) munie d’un
constructeur
class point
{ /* déclaration des membres privés */
int x ;
int y ;
public : /* déclaration des membres publics */
point (int, int) ; // constructeur
void deplace (int, int) ;
void affiche () ;
};

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 19


 Utilisation du constructeur
 La déclaration
 point a ;
 ne convient plus
 À partir du moment où une classe possède un
constructeur, il n’est plus possible de créer un
objet sans fournir les arguments requis par son
constructeur (sauf si ce dernier ne possède aucun
argument !).
 On peut donc écrire par exemple:
 point a(1,3) ;

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 20


 Exemple d’utilisation
main()
{
point a(5,2) ;
a.affiche () ;
a.deplace (-2, 4) ;
a.affiche () ;
point b(1,-1) ;
b.affiche () ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 21


 Cas d’un constructeur sans argument
 L’appel se fera avec
 point a;
 point a() ; // incorrect
 cela représenterait la déclaration d’une
fonction nommée a, ne recevant aucun
argument et renvoyant un résultat de type
point.
 Ce ne serait pas une erreur, mais il est évident
que toute tentative d’utiliser le symbole a
comme un objet conduirait à une erreur.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 22


 Exemple mettant en évidence les moments où sont appelés respectivement le
constructeur et le destructeur d’une classe.

#include <iostream>
using namespace std ;
class test
{
public :
int num ;
test (int) ; // déclaration constructeur
~test () ; // déclaration destructeur
};
test::test(int n) // définition constructeur
{
num = n ;
cout << "++ Appel constructeur avec num = " << num << "\n" ;
}
test::~test () // définition destructeur
{
cout << "-- Appel destructeur quand num = " << num << "\n" ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 23


 Exemple (suite)
void fct (int) ;
main()
{
test a(1) ;
for (int i=1 ; i<=2 ; i++)
fct(i) ;
}
void fct (int p)
{
test x(2*p) ;
}
--- Sortie du programme----
++ Appel constructeur avec num = 1
++ Appel constructeur avec num = 2
-- Appel destructeur quand num = 2
++ Appel constructeur avec num = 4
-- Appel destructeur quand num = 4
-- Appel destructeur quand num = 1
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 24
 Quelques règles à observer
 Par définition, un constructeur ne renvoie pas de
valeur ;
 aucun type ne peut figurer devant son nom (dans ce
cas précis, la présence de void provoquerait une
erreur).
 Par définition, un destructeur ne peut pas
disposer d’arguments et ne renvoie pas de
valeur. Ici aussi, aucun type ne peut figurer
devant son nom (et la présence de void
provoquerait une erreur).
 En théorie, constructeurs et destructeurs
peuvent être publics ou privés. En pratique, à
moins d’avoir de bonnes raisons de faire le
contraire, il vaut mieux les rendre publics.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 25


 Si un destructeur est privé, il ne pourra plus
être appelé directement.
 Le fait de rendre privé un constructeur peut

avoir de lourdes conséquences puisqu’il ne sera


plus utilisable, sauf par des fonctions membres
de la classe elle-même.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 26


 Le qualificatif static
 A priori, lorsque dans un même programme on
crée différents objets d’une même classe,
chaque objet possède ses propres membres
données.
Considérons la classe :
class exemple
{
int n ;
float x ;
.....
};

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 27


Une déclaration telle que : exemple a, b ;
conduit à une situation que l’on peut schématiser ainsi :

 Une façon de permettre à plusieurs objets de partager des


données, consiste à déclarer avec le qualificatif static les
membres données qu’on souhaite voir exister en un seul
exemplaire pour tous les objets de la classe.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 28


Retournons à l’exemple précédent avec :
On aura la situation suivante :
class exemple
{
static int n ;
float x ;
.....
};
main(){
exemple a, b ;
…..
}
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 29
 Initialisation des membres données statiques
 Les membres données statiques n’existent qu’en un seul
exemplaire, indépendamment des objets de la classe (même si
aucun objet de la classe n’a encore été créé).
 Dans ces conditions, leur initialisation ne peut plus être faite
par le constructeur de la classe.
 Cependant, il est impossible d’initialiser un membre statique
lors de sa déclaration, comme dans :

class exemple
{
static int n = 5 ; // erreur
.....
};
 Ecriture correcte :
 int exemple::n = 5 ;

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 30


 Par contre les membres statiques
constants peuvent être initialisés au
moment de leur déclaration.
 Mais, il reste quand même nécessaire de
les déclarer à l’extérieur de la classe
class exemple
{
static const int n=5 ; // initialisation OK (depuis la norme ANSI)
.....
}
const int exemple::n ; // déclaration indispensable (sans valeur)

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 31


 Exemple
#include <iostream>
using namespace std ;
class cpte_obj
{
static int ctr ; // compteur du nombre d’objets créés
public :
cpte_obj () ;
~cpte_obj () ;
};
int cpte_obj::ctr = 0 ; // initialisation du membre statique ctr
cpte_obj::cpte_obj () // constructeur
{
cout << "++ construction : il y a maintenant " << ++ctr << " objet(s)\n" ;
}
cpte_obj::~cpte_obj () // destructeur
{
cout << "-- destruction : il reste maintenant " << --ctr << " objet(s)\n" ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 32


 Exemple

void fct () ;
main()
{
cpte_obj a ;
fct () ;
cpte_obj b ;
}
void fct ()
{
cpte_obj u, v ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 33


 Leconcepteur de la classe point pourra créer le
fichier en-tête suivant :
--------point.h----------
class point
{ /* déclaration des membres privés */
int x ;
int y ;
public : /* déclaration des membres publics */
point (int, int) ; // constructeur
void deplace (int, int) ;
void affiche () ;
};

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 34


---------------fonction.cpp-------------
#include <iostream>
#include "point.h" // pour introduire les déclarations de la classe point
using namespace std ;
/* ----- Définition des fonctions membre de la classe point ---- */
point::point (int abs, int ord)
{ x = abs ; y = ord ;
}
void point::deplace (int dx, int dy)
{
x = x + dx ; y = y + dy ;
}
void point::affiche ()
{
cout << "Je suis en " << x << " " << y << "\n" ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 35


---------------principal.cpp-------------
#include <iostream>
#include "point.h" // pour introduire les déclarations de la classe point
using namespace std ;
main()
{
point a(5,2) ;
a.affiche () ;
a.deplace (-2, 4) ;
a.affiche () ;
point b(1,-1) ;
b.affiche () ;
}

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 36


 On peut avoir des classes imbriquées
 Mais leur portée est limitée à la classe (mais
on peut recourir à l’opérateur de résolution
de portée ::), comme dans cet exemple :
class A
{ public :
class B { ..... } ; // classe B déclarée dans la classe A
};
main()
{
Aa;
A::B b ; // déclaration d’un objet b du type de la classe B de A
}

 En pratique, cette situation se rencontre peu


souvent.
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 37
#include <iostream>
using namespace std;
class C
{
public :
static int i;
int j;
C() {
i++; j=i;
}
};
int C::i=0;

Qu’affiche le programme suivant ?


int main() {
C * x=new C();
C * y=new C();
C z;
cout<<z.i <<" et " << z.j<<endl;
z= *x;
cout<<z.i <<" et " << z.j<<endl;
Ck;
cout<<k.i <<" et " << ++k.j<<endl;
return 0;
}
Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 38
 À chaque étape de cet exercice, compilez votre
fichier pour contrôler qu'il est syntaxiquement
correct.
 1. Créez, dans un fichier, une classe
PersonneDetails.
 2. Ajoutez dans cette classe les attributs nom et
prenom de type chaîne de caractères.
 3. Ajoutez un attribut age de type entier.
 4. Ajoutez un constructeur qui initialise le nom et
le prenom.
 5. Ajoutez au fichier une fonction principale (main)
qui crée un objet de type PersonneDetails.
 Dans ce main, faites afficher les informations
concernant le nom et le prénom de l'objet créé.
Exécutez votre programme.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 39


 Dans la classe PersonneDetails,
 6. Ajoutez un constructeur qui initialise age en plus
de nom et prénom.
 7. Ajoutez une méthode nommée anniversaire qui
augmente age de 1.
 8. Ajoutez, une méthode nommée setNom qui
modifie la valeur de nom en fonction d'un paramètre.
Faites de même pour prénom et âge.
 9. Ajoutez une méthode nommée getNom qui rend la
valeur de nom. Faites de même pour prenom et age.
 10.Ajoutez une méthode nommée afficher qui affiche
pour une personne donnée, les trois attributs.
 11.Faites appel aux différentes méthodes définies ci-
dessus, sur un objet PersonneDetails.

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 40


 Comment programmer en C++ de H. Deitel
 Le langage C++ de B. Stroustrup
 C / C++ / C# - La bible du programmeur de
K. Jamsa
 Programmer en langage C++ de Claude
Delannoy

Programmation Orientée Objet avancée Dr Pélagie HOUNGUE 41

Vous aimerez peut-être aussi