Le document présente les concepts fondamentaux de la programmation orientée objets en C++, incluant les classes, les objets, les constructeurs et les destructeurs, ainsi que les structures et l'accès aux membres des classes. Il illustre également les différences entre C et C++ en termes de gestion des types et leur sécurité de données, tout en fournissant des exemples de code. Enfin, il aborde des notions avancées telles que l'allocation dynamique de mémoire, les membres statiques, et les constructeurs de recopie.

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