description

1. Programmation Orientée Objets en C++
R. Ben Abbou & A. Zahi
FSTF, Fez, Maroc

2. Programmation Orientée Objets
Chapitre 3
Classes Objets

3. Plan du Chapitre
 Introduction
 Ecarts de C++ par rapport à C ANSI
 Apports de C++

4. Plan du chapitre
 Structures
 Classes
 Constructeur & Destructeur
 Membres statiques
 Surdéfinition des fonctions
 Fonctions amies

5. Les structures
 En C les structures contiennent uniquement des
données
 Exemple
Struct point {
int x;
int y;
};
 En C++ les structures peuvent contenir des fonctions
 Exemple Struct point {
int x;
int y;
};

6. Les structures
 L’accès aux champs de la structure peut s’effectuer
directement ou via les fonctions
 Exemple
Point a, b;
a.x=10;
équivalent à a.initialise(10,20)
a.y=20;

7. #include<iostream.h>
Using namaspace std;
struct point {
int x; int y;
void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n";
}
int main()
{
point a,b;
a.initialise (10,20);
a.affiche();
a.deplace (5,5);
a.affiche();
b.x=1;
b.y=1;
b.affiche();
return 0;
}
Les structures
 Exemple en C++

8. Classes
 La notion de classe permet de :
 Généraliser la notion de type (structure)
 Réunir données et traitement dans la même entité
 Intégrer un certain niveau de sécurité
 Les données sont, généralement, protégées: seules les méthodes de
la classe peuvent y accéder

9. #include<iostream.h>
Using namaspace std;
class point {
private: // espace privé
int x; int y;
public: // espace publique
void initialise(int,int);
void deplace(int,int);
void affiche();
};
 Exemple
void point::initialise(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y
<<"n";
}
Classes

10.  Droit d’accès aux membres
 Trois modes d’accès aux membres d’une classe:
 Public : accès permis à partir de n’importe quel point du programme
 Private
• Seules les méthodes de la classe peuvent accéder au membre "privé"
• C’est la mode par défaut
 Protected : sémantique liée à l’héritage
Classes

11.  Droit d’accès aux membres
 Les modes d’accès concernent les membres données et les méthodes
 Une fonction membre privée ne peut être appelée qu’à partir d’une autre
fonction membre
 Les membres données peuvent être "public" mais c’est déconseillé, cela
contredit le concept d’encapsulation
 La structure en C++ est un cas particulier de classe où tous les membres
sont public
Classes

12.  Droit d’accès aux membres
 Les mots clés public, private et protected peuvent figurer
plusieurs fois lors de la déclaration de la classe
 Exemple
Classes
#include<iostream.h>
Using namaspace std;
class point {
private: // espace privé
int x; int y;
public: // espace publique
void initialise(int,int);
void deplace(int,int);
void affiche();
private: // espace privé
int calculer(int);
};

13. Classes
 Définition des fonctions membres
 Les fonctions membres sont définies de la même manière que
les fonctions ordinaires
 Les fonctions membres peuvent accéder aux membres
données (sans les passer en paramètre)
 La fonction membre est indexée (opérateur de porté ::) par le
nom de sa classe

14.  Définition des fonctions membres
 Syntaxe
 Exemple
void point::deplace(int dx,int dy)
{
x+=dx;
y+=dy;
}
void point:: affiche()
{
cout << "position :" <<x <<"," <<y <<"n";
};
Classes
Type nom_classe :: nom_fonction (type param,…)
{
corps de la fonction
}

15.  Instanciation de classes
 Création de variables de type classes objets
 Se fait par une simple déclaration :
 Objets statiques :
nom_class ob1, ob2; // objets statiques
 Objets dynamiques nécessité d’allouer de la mémoire
nom_class *ob1, *ob2 // objets dynamiques
ob1 = new nom_class ; // allocation de la mémoire
ob2 = new nom_class ; // allocation de la mémoire
Classes

16.  Instanciation de classes  Affectation d’objets
nom_class ob1, ob2;
ob2 = ob1;
 Copie les valeurs des membres données de ob1 dans ob2
 Attention!! Si l’objet contient des membres données
dynamiques
Risque d’incohérence
Classes

17.  Instanciation de classes  Exemple
Classes
#include<iostream.h>
Using namaspace std;
class point {
int x; int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n";
}
Int main() {
point a,b;
a.initialise (10,20);
a.affiche();
b=a;
b.affiche();
b.deplace(3,3);
b.affiche();
a.affiche();
return 0;
}

18.  Membre données dynamique dans une classe
class nom_class {
typ * m ;
.
.
.
};
 Allocation lors de l’initialisation
 Partage de l’espace dans la cas d’une affectation entre deux
objets
nom_class obj1, obj2;
Obj1 = obj2;
Obj1 et obj2 partagent le même espace de l’attribut m,
Classes

19.  Instanciation de classes  Exemple
Classes
#include<iostream.h>
Using namaspace std;
class point {
int *x; int *y; // membres dynamiques
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
X= newt int; y = new int; //allocation de la
mémoire
*x=abs; *y=ord;
}
void point::deplace(int dx,int dy)
{
*x+=dx; *y+=dy;
}
void point::affiche()
{
cout << "position :" <<*x <<"," <<*y <<"n";
}
int main() {
point a,b;
a.initialise (10,20);
a.affiche();
b=a;
b.affiche();
b.deplace(3,3);
a.affiche(); //a aussi de déplace
return 0;
}

20.  Le pointeur this
 this pointeur qui pointe sur l’objet en cours
 Crée dans les fonctions membres
 Exemple
Classes
#include<iostream>
using namespace std;
class point { int x;
int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche() {
cout << this-> x;
cout << this-> y;
};

21. Constructeur / Destructeur
 Deux fonctions membres spéciales
 Constructeur : initialise les objets de la classe
 Destructeur : détruit les objets de la classe
 Toutes les deux sont facultatives

22.  Initialise les membres données de l’objet lors de sa
déclaration par:
 Les valeurs passées en paramètres
 Un autre objet existant de la même classe (constructeur de recopie)
 Alloue de la mémoire si l’objet contient une partie dynamique
Constructeur Rôle

23.  Porte le nom de la classe
 N’a pas de type de retour
 Peut avoir des paramètres
 Est facultatif S’il n’est pas défini le compilateur génère
un constructeur par défaut
Constructeur Caractéristiques

24.  Syntaxe
nom_classe::nom_classe([param1,…]) {…}
 Peut être surdéfini
nom_classe::nom_classe(param1,param2) {…}//avec deux paramètres
nom_classe::nom_classe(param1) {…} // un seul paramètre
nom_classe::nom_classe() {…} // sans paramètres
Constructeur Caractéristiques

25.  Appelé implicitement lors de la déclaration
 Objets statiques
nom_classe ob1(val1,val2);
nom_classe ob2(val);
nom_classe ob3;
 Objets dynamiques
nom_classe *ob4; ob4 =new nom_classe (val1,val2)
nom_classe *ob5; ob5 =new nom_classe (val)
nom_classe *ob6; ob6 =new nom_classe ()
Constructeur Caractéristiques

26. #include<iostream.h>
class point {
int x;
int y;
public:
point(int,int); // un constructeur à deux paramètres
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n"; }
Constructeur Exemple
void main()
{
point a(10,20),b(30,30);
point c; // erreur
a.affiche();
a.deplace (5,5);
a.affiche();
b.affiche();
}

27. Constructeur membres données dynamiques
#include<iostream>
using namespace std;
class dvecteur {
int dim; // dimension maximale
float *V;
public:
dvecteur(int,float*);
void decaler(float);
void afficher();
};
dvecteur::dvecteur (int n,float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}
void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;
}
void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" n" ;
}
int main()
{
float t1[]={1,1,1}, t2[]={2,2,2,2};
dvecteur V1(3,t1),V2(4,t2);
V2 = V1;
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}

28. Constructeur de recopie Rôle
 Initialise l’objet lors de sa déclaration par un autre objet
Mamouni
Mustapha
C67965
Mamouni
Mustapha
C67965
P_existant P_nouveau

29.  Porte le nom de la classe
 N’a pas de type de retour
 A un seul paramètre : une référence à un objet
 Est facultatif S’il n’est pas défini le compilateur génère
un constructeur par défaut
 Ne peut pas être surdéfini
Constructeur de recopie Caractéristiques

30.  Syntaxe
nomclasse :: nomclasse (nomclasse&) { …}
 Est appelé implicitement lors des situations suivantes:
 Déclaration initialisation
nomclasse nouveau_objet=objet_existant;
 Passage par valeur d’un objet en paramètre
f(nomclasse objet)
 Retour d’un objet déjà existant par une fonction
return objet_existant;
Constructeur de recopie Caractéristiques

31. #include<iostream.h>
class point {
int x;
int y;
public:
point(int,int); // un constructeur à deux paramètres
point(const point&); // un constructeur à deux paramètres
void deplace(int,int);
void affiche();
};
point::point(int abs,int ord)
{
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"n"; }
Constructeur Exemple
point::point(const point &p)
{
x=p.x; y=p.y;
}
void f(point p)
{
p.affiche();
}
point g()
{
point h(1,1);
return h;
}
void main()
{
point a(10,20);
point c=a;
c.affiche();
c.deplace (5,5);
cout << "ici la fonction f" << endl;
f(c);
cout << "ici la fonction g" << endl;
c = g();
c.affiche();
return 0;
}

32. Constructeur de recopie membres données
dynamiques
 Risque d’incohérence
 Les deux objets (initial et la copie) se partageront une
même zone mémoire
 La modification des données de l’un affectera l’autre

33. Constructeur membres données dynamiques
#include<iostream>
using namespace std;
class dvecteur {
int dim; // dimension maximale
float *V;
public:
dvecteur(int,float*);
dvecteur(dvecteur&);
void decaler(float);
void afficher();
};
dvecteur::dvecteur (int n,float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}
void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;
}
void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" n" ;
}
dvecteur::dvecteur (dvecteur& vect)
{
dim=vect.dim;
V= new float[dim];
for(int i=0;i<dim;i++)
V[i]=vect.V[i];
}
int main()
{
float t1[]={1,1,1};
dvecteur V1(3,t1);
dvecteur V2 = V1;
dvecteur V3(V1);
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}

34. Destructeur Rôle
 Libération des ressources de l’objet à la fin de son
utilisation
 Libération de la zone mémoire allouée par un
constructeur

35.  Porte le nom de la classe précédé par le caractère ~
 N’a pas de paramètres
 N’a pas de type de retour
 Ne peut pas être surdéfini
Destructeur Caractéristiques

36. Destructeur Exemple
#include<iostream>
using namespace std;
class dvecteur {
int dim; // dimension maximale
float *V;
public:
dvecteur(int,float*);
dvecteur(dvecteur&);
~dvecteur();
void decaler(float);
void afficher();
};
dvecteur::dvecteur (int n,float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}
void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;
}
void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" n" ;
}
dvecteur::dvecteur (dvecteur& vect)
{
dim=vect.dim;
V= new float[dim];
for(int i=0;i<dim;i++)
V[i]=vect.V[i];
}
dvecteur::~dvecteur ()
{
dim=0;
delete V;
cout<<"n Appel du destructeurn";
}
void scenario(float d)
{
float t1[]={1,1,1};
dvecteur V1(3,t1);
V1.afficher(); V1.decaler(d);
V1.afficher();
}
int main()
{
int d;
for(d=1;d<4;d++)
scenario(d);
return 0;
}

37. Classe d’allocation static
 Stockage dans la zone statique
 Durée de vie permanente, égale à celle du programme
 Même portée que les variables automatique
 Initialisation au moment de la compilation, initialisation
par défaut à 0
 Syntaxe
static float x;

38. #include <stdio.h>
void fonct()
{
static int x=0;
int y=0;
printf("x = %d, y = %dn",x++, y++);
}
int main()
{
int i ;
for (i=0;i <10; i++)
{
printf(" iteration = %d ", i);
fonct();
}
return 0;
}
Classe d’allocation static Exemple

39.  Applicable aux méthodes et aux attributs
 Propriété indépendante de tous les objets (propriété de
la classe)
Classe d’allocation static

40. Membres données static
 Lors de la déclaration des objets chaque objet possède
ses propres membres données
 Exemple
Ob1 Ob2
10
15 30
20

41. Membres données static
 Un membre static est partagé par tous les objets de la classe
 Syntaxe Le membre est précédé par le mot clé static lors de
la déclaration de la classe
static type nom_var;
 L’initialisation n’est pas automatique
Type class_name::ident = 0;
Ob1 Ob2
10
15 30
20
Ob3

42. Membres données Static Exemple
#include<iostream.h>
class point {
static int nb;
int x;
int y;
public:
point(int,int);
void deplace(int,int);
void affiche();
};
int point::nb=0;
point::point(int abs,int ord)
{
nb++;
x=abs; y=ord;
}
void point::deplace(int dx,int dy)
{
x+=dx;
y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"nombre
d'objets" << nb <<"n";
}
void main()
{
point a(10,20);
a.affiche();
a.deplace (5,5);
a.affiche();
point b(30,30);
b.affiche();
}

43. Fonctions membres static
 Sont indépendantes de tous les objets de la classe
 Agissent sur des membres static
 Sont appelées sans référence à un objet référencées
directement par le nom de la classe
nom_classe::fonct_static(…);

44. Fonctions membres static
 Peuvent être appelées avant la création de tout objet
 Syntaxe
class nom_classe {
….
public:
…
static type fonct_static(….);
};

45. #include<iostream.h>
class point {
static int nb;
int x;
int y;
public:
point(int,int);
void deplace(int,int);
void affiche();
static void compteur();
};
int point::nb=0;
point::point(int abs,int ord)
{
nb++;
x=abs; y=ord;
}
void point::compteur()
{
cout <<"n nombre de points :"<<nb;
}
void point::deplace(int dx,int dy)
{
x+=dx; y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y
<<"nombre d'objets" << nb <<"n";
}
void senario(int i)
{
point a(i,i);
a.affiche();
}
void main()
{
point a(i,i);
a.affiche();
point::compteur();
for(int i=0;i<4;i++)
senario(i);
return 0;
}
Fonctions membres static Exemple

46. Surdéfinition des fonctions membres
 La surdéfinition peut être appliquée aux fonctions
membres d’une classe
 Plusieurs fonctions membres portent le même nom mais diffèrent
dans le contenu selon le type et/ou le nombre de paramètres
 Sémantiquement ces fonctions font la même action (ex afficher)
 Le compilateur choisit la fonction à invoquer selon les paramètres
effectifs
 Plus de lisibilité : pas besoin de chercher plusieurs identificateurs
pour la même action

47. #include<iostream.h>
class point {
int x;
int y;
public:
void initialise(int,int);
void initialise(int);
void initialise ();
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int
ord)
{
x=abs;
y=ord;
}
void point::initialise(int c)
{
x=c;
y=c;
}
void point::initialise()
{
x=100;
y=100;
}
Surdéfinition des fonctions membres

48. Paramètres par défaut des fonctions membres
 Une fonction membre peut attribuer des valeurs par
défaut à certains paramètres omis lors de l’appel
 Seuls les derniers paramètres peuvent avoir des valeurs
par défaut
 ≠ surdéfinition des fonctions Une seule fonction
 !!! Attention risque d’ambiguïté avec la surdéfinition

49. class point {
int x;
int y;
public:
void initialise(int =10,int =10);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs;
y=ord;
}
Paramètres par défaut des fonctions membres Exemple

50. Fonctions amies
 Une fonction amie est une fonction non membre d’une classe
et possédant le droit d’accès aux membres privés de ses
objets.
 Intérêt : résoudre certains problèmes de communication entre
objets
 Fonction qui a besoin, dans certains cas, d’accéder aux
membres privés de deux classes différentes
 Attention !! : Violation du concept d’encapsulation
 L’amitié est déclarée par le mot clé friend

51. Fonctions amies
 Fonction indépendante et amie d’une classe
 Syntaxe
class A {
…
public:
…
friend type_retour fonct_amie(…);
…
};
// définition de la fonction amie
type_retour fonct_amie(…)
{
…
}

52. Fonctions amies
 Remarque
// Attention !!!! Fausse définition
type_retour A::fonct_amie(…)
{
…
}

53. Fonctions amies
 Fonction membre d’une classe A et amie d’une ou plusieurs classes
 Syntaxe
class A {
…
public:
…
type_retour fonct_amie(…);
…
};
class B {
…
public:
…
friend type_retour A::fonct_amie(…);
};

54. Fonctions amies
 Toutes les fonctions membres d’une classe A sont amies d’une
autre classe B
 Syntaxe
class A {
…
public:
…
};
class B {
…
public:
…
friend class A; // les fonctions membres sont amies de classe B
};

55. Fonctions amies  Exemple1
class point {
int x;
int y;
public:
point(int,int);
void deplace(int,int);
friend int complexe::coincide(point&);
void affiche();
};
class complexe {
int x;
int y;
public:
complexe(int,int);
int coincide(point&);
void affiche();
…
};

56. class point {
int x;
int y;
public:
point(int,int);
void deplace(int,int);
friend int coincide(complexe&, point&);
void affiche();
};
class complexe {
int x;
int y;
public:
complexe(int,int);
int coincide(point&);
friend int coincide(complexe&,point&);
void affiche();
…
};
Fonctions amies  Exemple2