Classes et Objets

Mohammed OUANAN

1
 Plan
Structures
Classes
Droit d’accès aux membres
Définition des fonctions membres
Instances de classe

Constructeur & Destructeur

Objets dynamiques
Membres statique
Données
Fonctions

Surdéfinition des fonctions

Fonctions amies
Surcharge des opérateurs
Organisation du code

2
 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;
void initialise(int,int);
void deplace(int,int);
void affiche();
};

3
 Les structures

Les champs de la structure peuvent être accédés

directement ou via les fonctions

Exemple
Point a,b;

a.x=10;
a.y=20; équivalent à a.initialise(10,20)

4
 Les structures
Exemple
#include<iostream.h>
struct point { int x;
void main()
int y;
void initialise(int,int); {
void deplace(int,int); point a,b;
void affiche(); a.initialise (10,20);
}; a.affiche();
void point::initialise(int abs,int ord) a.deplace (5,5);
{ a.affiche();
x=abs; b.x=1;
y=ord;
b.y=1;
}
void point::deplace(int dx,int dy) b.affiche();
{ }
x+=dx;
y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
}
5
 Notion de classe

Généralisation de la notion de type struct

Réunir données et traitement dans la même entité

Intégration d’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

6
 Notion de classe
Exemple

class point { int x;

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

7
 Classes
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é"

mode par défaut

Protected : sémantique liée à l’héritage

8
 Classes
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 publics

9
 Classes
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
class point { private:
int x;
int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
private:
float calculer();
};

10
 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.

Syntaxe
Type nom_classe :: nom_fonction (type param,…)
{
…
}
11
 Classes
Exemple d’utilisation
#include<iostream.h>

class point { int x;

int y;

public:

void initialise(int,int);

void deplace(int,int);

void affiche();

};

12
 Classes
Exemple d’utilisation

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";
}

13
 Classes
Instances de classe : objets

L’instanciation d’une classe se fait par une simple déclaration

Nom_class ob1,ob2; // objets statiques

Affectation d’objets

ob2 = ob1;
Copie les valeurs des membres données de ob1 dans ob2

14
 Classes
Exemple d’utilisation

void main()
{
point a,b;
a.initialise (10,20);
a.affiche();
}

15
 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

16
 Constructeur

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

17
 Constructeur

Caractéristiques :

Porte le nom de la classe

N’a pas de type de retour

Peut avoir des paramètres et peut ne pas avoir des paramètres

Est facultatif

S’il n’est pas défini le compilateur génère un constructeur par défaut

18
 Constructeur
Caractéristiques:

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

Est appelé implicitement lors de la déclaration

Nom_classe ob1(val1,val2);

Nom_classe ob2(val);

Nom_classe ob3;

19
 Constructeur : exemple (1)

#include<iostream.h>
class point { int x;
int y;

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

20
 Constructeur : exemple (1)

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";
}

21
 Constructeur : exemple (1)

void main()
{
point a(10,20),b(30,30);
point c; // erreur
a.affiche();
a.deplace (5,5);
a.affiche();
b.affiche();
}

22
Constructeur avec argument par défaut

On utilise souvent dans les constructeurs des arguments avec

définition de valeur par défaut. Ceci permet de rendre valide la
déclaration d’un objet sans argument : dans ce cas, les valeurs
par défauts sont utilisées. Le constructeur de la classe point
peut être définie dans la classe par :

Point (int abs=0,int ord=0){x=abs ; y=ord}

Dans ce cas on peut déclarer dans la fonction main :

Point p(1,2) ; // un point de coordonnées 1et 2 est créé
Point b ; //un point de coordonnées 0 et 0 est créé
Point c(3) ; //point de coordonnées 3 et 0 est créé.

23
 Constructeur : exemple (2)
Allocation dynamique

#include<iostream.h>
class jours_travail { int nb_jour;
int *T;

public:
jours_travail(int);
void ajoute(int);
void supprime(int);
void affiche();
};

24
 Constructeur : exemple (2)
Allocation dynamique
jours_travail::jours_travail (int n) void jours_travail::supprime(int j)
{ {
nb_jour=n; int *T1,k=0;
T= new int[n]; T1=new int[nb_jour-1];
for(int i=0;i<nb_jour;i++) for(int i=0;i<nb_jour;i++)
T[i]=i; if (T[i]!= j) {
}
T1[k]=T[i];
void jours_travail::ajoute(int j)
k++; }
{ nb_jour--;
int *T1; delete T;
T1=new int[nb_jour+1]; T=T1;
for(int i=0;i<nb_jour;i++) }
T1[i]=T[i];
T1[nb_jour]=j; void jours_travail::affiche()
nb_jour++; {
delete T;
for(int i=0;i<nb_jour;i++)
T=T1;
cout << T[i] <<" \n" ;
}
}

25
 Constructeur : exemple (2)
Allocation dynamique

void main()
{
jours_travail cal(3);
cal.ajoute(5);
cal.supprime(1);
cal.affiche();
}

26
 Destructeur

Libère les ressources de l’objet à la fin de

son utilisation

Libère la zone mémoire allouée par un

constructeur

27
 Destructeur

Caractéristiques
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

28
 Destructeur : exemple

#include<iostream.h>
class jours_travail { int nb_jour;
int *T;

public:
jours_travail(int);
~jours_travail();
void ajoute(int);
void supprime(int);
void affiche();
};

29
 Destructeur : exemple
#include<iostream.h> void jours_travail::ajoute(int j)
jours_travail::jours_travail (int n) {
int *T1;
{
T1=new int[nb_jour+1];
nb_jours=n; for(int i=0;i<nb_jour;i++)
T= new int[n]; T1[i]=T[i];
for(int i=0;i<nb_jour;i++) T1[nb_jour]=j;
T[i]=i; nb_jour++;
} delete T;
T=T1;
jours_travail::~jours_travail () }
{ void jours_travail::supprime(int j)
nb_jour=0; {
delete T; int *T1,k=0;
} T1=new int[nb_jour-1];
for(int i=0;i<nb_jour;i++)
void jours_travail::affiche() if (T[i]!= j) {
{ T1[k]=T[i];
for(int i=0;i<nb_jour;i++) k++; }
nb_jour--;
cout << T[i] <<" \n" ; delete T;
} T=T1;
30 }
 Destructeur : exemple

void scenario(int j)
{
jours_travail cal(j);
cal.ajoute(j+1);
cal.affiche();
}
void main()
{
for(int =1; i<5; i++)
scenario(i);
}

31
 Affectation des objets

Il est possible d’affecter un objet à un autre objet de même type. Il

y a alors recopiée des valeurs des champs des données (qu’ils
soient publics ou privés). Toutefois, si parmi ces champs se
trouvent des pointeurs, les emplacements pointés ne seront pas
soumis à cette recopie. Pour cela, il faut « surdéfinir » le
constructeur de recopie

32
 Constructeur de recopie

Caractéristiques
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

33
 Constructeur de recopie

Syntaxe :
nomclasse :: nomclasse (nomclasse&) { …}

Est appelé implicitement lors des situations suivantes:

La déclaration initialisation:
nomclasse nouveau_objet=objet_existant;

Passage par valeur d’un objet en paramètre

f( nomclasse nouveau_objet objet_existant)

Retour d’un objet dans une fonction

nomclasse nouveau_objet=objet_existant;
return objet_existant;

34
 Constructeur de recopie : exemple (1)

#include<iostream.h>
class point { int x;
int y;

public:
point(int,int);
point(point&);
~point();
void deplace(int,int);
void affiche();
};

35
Constructeur de recopie : exemple (1)
point::point(int abs,int ord)
{
x=abs;
y=ord;
}
point::point(point &p)
{
x=p.x;
y=p.y;
}
void point::deplace(int dx,int dy)
{
x+=dx;
y+=dy;
}

void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
}
36
Constructeur de recopie : exemple (1)

void main()
{
point a(10,20);
point c=a;
c.affiche();
c.deplace (5,5);
c.affiche();
}

37
Constructeur de recopie : exemple (2)
Allocation dynamique

#include<iostream.h>
class jours_travail { int nb_jour;
int *T;

public:
jours_travail(int);
jours_travail(jours_travail &);
~jours_travail();
void ajoute(int);
void supprime(int);
void affiche();
};

38
Constructeur de recopie : exemple (2)
Allocation dynamique
#include<iostream.h> void jours_travail::ajoute(int j)
jours_travail::jours_travail (int n) {
{ int *T1;
nb_jours=n; T1=new int[nb_jour+1];
T= new int[n]; for(int i=0;i<nb_jour;i++)
for(int i=0;i<nb_jour;i++)
T1[i]=T[i];
T[i]=i;
} T1[nb_jour]=j;
nb_jour++; delete T;
jours_travail::jours_travail (jours_travail & T=T1;
cal) }
{
nb_jour=cal.nb_jour; void jours_travail::supprime(int j)
T= new int[nb_jour]; {
for(int i=0;i<nb_jour;i++) int *T1,k=0;
T[i]=cal.T[i]; T1=new int[nb_jour-1];
} for(int i=0;i<nb_jour;i++)
if (T[i]!= j) {
void jours_travail::affiche() T1[k]=T[i];
{ k++; }
for(int i=0;i<nb_jour;i++) nb_jour--;delete T;
cout << T[i] <<" \n" ;
T=T1;
}
}
39
Constructeur de recopie : exemple (2)
Allocation dynamique

jours_travail::~jours_travail ()
{
nb_jour=0; void main()
delete T; {
}
jours_travail cal(3);
cal.ajoute(5);
cal.supprime(1);
Jours_travail cal1=cal;
cal1.ajoute(4);
cal1.affiche();
}

40
 Type d’objets et leurs durée de vie

Objets automatiques : ils sont crées à l’intérieur

d’une fonctions ; créer à la déclaration et détruit à la
fin de la fonction.

Objets statiques : ils sont crées en dehors de toute

fonction ou bien dans une fonction mais précédés par
le terme static.

Objets temporaires: Il sont crées par un appel

explicite au constructeur (a=point(1,2) ;) et détruit
juste après qu’il ne sera plus utile.

Objets dynamiques : Ils sont crées par l’opérateur

new et détruit par l’opérateur delete.

41
 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;

42
 Classe d’allocation static
Exemple

#inlude <stdio.h>
void fonct()
{
static int x=0;
int y=0;
printf(“x = %d, y = %d\n”,x++, y++);
}

main()
{
int i ;
for (i=0;i <10; i++)
{
printf(’’ iteration = %d ’’, i)
fonct();
}
}

43
 Classe Static et Classes

Applicable aux méthodes et aux attributs

Propriété indépendante de tous les objets

(propriété de la classe)

44
 Les membres données
Classe de stockage static

Lors de la déclaration des objets :

Chaque objet possède ses propres membres données

Exemple :

Ob1 Ob2

10 20

15 30

45
 Les membres données
Classe de stockage 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::nom_var = 0;

Ob1 Ob2
15 20 30

10

46
Ob3
 Les membres données static
Exemple 1
void point::deplace(int
#include<iostream.h> dx,int dy)
class point { static int nb; {
int x; x+=dx;
int y; y+=dy;
}
public: void point::affiche()
point(int,int); {
void deplace(int,int); cout << "position :" <<x
void affiche(); <<"," <<y <<"nombre d'objets"
}; << nb <<"\n";
int point::nb=0; }
void main()
point::point(int abs,int ord) {
{ point a(10,20);
nb++; a.affiche();
x=abs; a.deplace (5,5);
y=ord; a.affiche();
} point b(30,30);
b.affiche();
}
47
 membre static
Exemple 2
class UneClasse
{
// private:
static long a;
public:
static long b;
void UneMéthode(){ a=2;b=3; }
};
long UneClasse::a = 5; // initialisation de a
long UneClasse::b = 6; // initialisation de b
void f()
{
UneClasse::a = 8;// erreur de compilation:
//a est privé
UneClasse::b = 9 ;
48
}
Les propriétés d’une variable statique dans une méthode
Exemple 3
class UneClasse
{ public:
long Increment()
{
static long a=0;//a vaut 0 lors du premier
//appelde la méthode Increment()
a++;
return a; }
};
int main() {
UneClasse classe1, classe2;
long aa = classe1.Increment();//aa vaut 1
aa = classe2.Increment();// aa vaut 2
return 0;
}
49
 Les 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(…);

50
 Les fonctions membres static
Peuvent être appelées avant la création de tout objet

Syntaxe:
class nom_classe{
….
public:
…
static type fonct_static(….);
};

51
 Exemple 4:

class UneClasse
{
public:
static long a;
long b;
static void Increment()
{
a++;
b++;// erreur de compilation:
//ne peut accéder à un attribut non-statique
}
};
long UneClasse::a = 0;

void f()
{
UneClasse::Increment();//appel à la fonction
//statique
}

52
 Les fonctions membres constantes

C++ offre la possibilité de définir des méthodes

constantes, c’est à dire que le compilateur
garantit que leurs appels ne modifient aucun
attribut de l’objet.

Il suffit de rajouter le mot clé const à la fin de

la méthode.

Le compilateur n’autorise que l’appel de méthodes

constantes sur un objet constant.

Les constructeurs et les destructeurs sont les

seules méthodes non constantes qui peuvent être
appelées pour des objets constants.

53
 Les fonctions membres constantes
Exemple et syntaxe:

class UneClasse
{
public:
long m_Attribut;
void MaMéthode() const; //l’entete
//(prototype de la méthode)
};
void UneClasse::MaMéthode()const //décalaration
//de la méthode
{
m_Attribut++;// erreur de compilation :
// la méthode est constante
}
54
 Les fonctions membres constantes

Remarques:
le terme const doit figurer à la fois dans la déclaration de la
fonction et dans l’entête de cette fonction.

On utilisera souvent le mot clé const sur les méthodes

accesseur ( getAttribut,); ces méthodes qui ne contentent
que de renvoyer la valeur d’un attribut pour respecter le
principe d’encapsulation qui dit que l’attribut doit être
public.

55
Surdéfinition des fonctions membres

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 qui choisit la fonction à invoquer selon les paramètres

effectifs

Plus de lisibilité : pas besoin de chercher plusieurs identificateurs

pour la même action

56
Surdéfinition des fonctions membres

Exemple void point::initialise(int abs,int ord)

{
class point { int x; x=abs;
int y; y=ord;
}
public:
void point::initialise(int c)
void initialise(int,int); {
void initialise(int); x=c;
y=c;
void initialise (); }
void deplace(int,int); void point::initialise()
{
void affiche();
x=100;
}; y=100;
}

57
Surdéfinition des fonctions membres

void main()
{
point a,b,c;
a.initialise(1,2);
b.initialise(3);
c.initialise();
a.affiche();
b.affiche();
}

58
 Paramètres par défaut des fonctions membres

Une fonction membre peut attribuer des valeurs par défaut a 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

59
 Paramètres par défaut des fonctions membres

Exemple
class point { int x;
void main()
int y; {
public: point a,b,c;
void initialise(int =0,int =0); a.initialise(1,2);
void deplace(int,int); b.initialise(3);
void affiche(); c.initialise();
}; a.affiche();
void point::initialise(int abs=0,int ord=0) b.affiche();
{
x=abs; }
y=ord;
}

60
 Le pointeur this

Dans toutes les méthodes (non statiques) de toutes les classes, C++
défini automatiquement un pointeur nommé this (auto référence). C’est
un pointeur, du type de la classe, qui pointe vers l’objet courant. Il est
utilisé lorsque aucun autre nom d’objet n’a été spécifié.

On s’en sert surtout pour communiquer un accès à l’objet courant ou à

une entité extérieur à la classe.

61
 Le pointeur this: Exemple
class UneClasse; // déclaration de la classe

void fct(UneClasse * pUneClasse ); //fonction globale

class UneClasse
{
long m_Attribut;
int x;
int y;
public: UneClasse(int, int) ;
void UneMethode (long) ;
};
Communiquer l’ accès à une entité extérieur à la classe.
void UneClasse:: UneMethode (long a)
{

fct(this); // communique l’adresse de l’objet

//courant à l’extérieur de la classe
}
62
 Le pointeur this: Exemple
Communiquer l’accès à l’objet courant :
Supposons que le corps du constructeur avec paramètres de la classe
UneClasse est:
UneClasse::UneClasse(int x , int y) {
x = x;
y = y ;}

Ça passe bien à la compilation. Mais, C++ n'est pas capable de

distinguer ces identificateurs.
Il faut alors utiliser l'auto référence this qui représente l'objet courant :

UneClasse :: UneClasse(int x , int y) {

this->x = x ;
this->y = y ;
}
On interprète : this->x comme l’abscisse du point courant.

63
 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 communications 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 de l’encapsulation

L’amitié est déclarée par le mot clé freind

64
 Fonctions amies
Fonctions indépendante amie d’une classe

Syntaxe:
Class A {
…
Public:
…
friend type_retour fonct_amie(…);
…
};

// définition de la fonction amie

type_retour fonct_amie(…)
{
…
}
// Attention !!!! Fausse définition
type_retour A::fonct_amie(…)
{
…
65 }
 Fonctions amies
Exemple1: fonction indépendante amie d’une classe
class Point {
private :
int x, y ; // abscisse et ordonnée
public:
Point(int abs, int ord) {
x = abs; y = ord;
}
friend void afficher(const Point&, char * = "");
};
void afficher(const Point& p, char * message) {
cout << message << "<x = "<< p.x << ", "
<< " y = " << p.y << ">\n";}
void main() {
Point p = Point(8, 7);
afficher(p, "p (avec fonction amie) : ");
}
/* Exécution:
p(avec fonction amie) : <x =8, y =7>*/

66
 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(…);
};

67
 Fonctions amies
Exemple2: Fonctions membre d’une classe amie d’une autre classe
class A; // déclaration de la classe A
class B { // définition de la classe B.
public :
void afficher (A&);
};
class A { // définition de la classe A
int i;
public :
A (int e=10){ i=e;}
friend void B::afficher (A &);
};
void B::afficher( A & a) {
cout << a.i << endl; // afficher a accès au champ privé i
de la classe A
}
void main() {
A x1(5);
A x2;
B y;
y.afficher(x1); // en sortie 5
y.afficher(x2); // en sortie 10
}
68
 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
//la classe B
};

69
 Fonctions amies
fonction amie de plusieurs classes:
class A;
class B {
int j;
public :
B (int w=15){j=w; }
friend void afficher (A&, B&);//afficher amie de A et B.
};
class A {
int i;
public :
A (int e=10){i=e; }
friend void afficher (A&, B&);//afficher amie de A et B.
};

void afficher( A & a, B & b) {

cout<<" A:i=" <<a.i <<endl;//accès au champ privé de A
cout<<" B:j=" <<b.j <<endl; //accès au champ privé B
}

70
 Fonctions amies

Exemple 3
class point { int x;
class complexe { int x;
int y;
int y;

public: public:
point(int,int); complexe(int,int);
void deplace(int,int); int coincide(point&);
void affiche();
friend int complexe::coincide(point&);
…
void affiche(); };
};

71
 Fonctions amies

Exemple 4
class point { int x;
int y; class complexe { int x;
int y;
public:
public:
point(int,int);
complexe(int,int);
void deplace(int,int); friend int coincide(complexe&,point&);
friend int coincide(complexe&,point&); void affiche();
void affiche(); };
};

72
 Surcharge des opérateurs
Opérateur?
Opération entre des opérandes.

Un appel à un opérateur est similaire à un appel de

fonctions.

A Op B se traduit par A.operatorOp(B)

Exemples
a+b a.operator+(b)
b+a b.operator+(a)
a=b a.operator=(b)
73
++a a.operator++()
 Surcharge des opérateurs
Surcharge?
Redéfinition d’une fonction avec le même nom mais pas avec les
mêmes paramètres.
Pour les opérateurs :
sont définis uniquement pour les types de base (int, float, etc.)
surcharge = redéfinition avec des opérandes de type class.
Intérêt : utilisation plus naturel pour certaines classes
Pour l’exemple de la classe point:
class point {...};
point a, b, c;
Il est plus naturel d’écrire a = b + c;
que d’écrire a = b.addition(c)

74
 Surcharge des opérateurs
On ne peut surcharger que les opérateurs qui existent déjà. On
ne peut pas en inventer!

Presque tous les opérateurs sont surchargeables sauf:

. Opérateur pointeur vers un membre via objet

* Opérateur pointeur vers un membre via objet

:: Opérateur de résolution de portée

?: Opérateur conditionnel ternaire

sizeof Opérateur déterminant la taille en octets

75
 Surcharge des opérateurs

Pour surcharger un opérateur Op, on doit

définir une fonction :
Désignée par: operator Op
L’un des paramètres est obligatoirement de type
classe

On doit respecter la parité binaire et unaire.

« a+b » : parité binaire
« a++ » : parité unaire

76
 Surcharge des opérateurs

On doit respecter la priorité et l’associativité

« a+b*c » : La multiplication (*) est exécutée
avant l'addition (+) même lorsque les opérateurs
sont redéfinis.

Il n’y a pas de liens sémantiques implicites

entre opérateurs redéfinis
a+=b n'est pas forcément la même opération
que a=a+b
a==b n'implique pas que a!=b soit faux!

77
 Surcharge des opérateurs

Un opérateur peut être défini:

Comme une fonction non membre de la classe
(fonction amie)
Utilisée dans le cas des opérateurs symétriques
Exemple: les opérateurs arithmétiques

Comme une fonction membre de la classe

Utilisée dans le cas des opérateurs asymétriques
Exemples: opérateurs arithmétiques d’affectation

78
 Exemple: l’opérateur d’adition

#include<iostream.h>
class point { int x; void main()
int y; {
point a(1.2),b(2,3),c(0,0);
Public:
point(int,int); c=a+b ;//c=a.operator
+(b) ;
void deplace(int,int);
void affiche(); c=a+b+c;//c=(a.operator+
point(); (b)).operator+(c) ;
Point operator +(Point) ; c.affiche();
}; }
Point Point:: operator +(Point a)
{ Point res;
res.x=x+a.x ;
res.y=y+a.y ;
return res ;
}

79
 Surcharge de l’affectation
Le problème déjà résolu par le constructeur par recopie est
comparable a celui posé dans le cas d’affectation entre objets
d’une classe. Mais, dans ce deuxième cas, on distingue la
situation suivante : (b=a)

On peut avoir l’affectation d’un objet à lui-même.

Affectation entre deux objets crées (deux emplacements
dynamiques) l’emplacement déjà référencé par b doit être libéré,
mais on doit s’assurer qu’il n’est pas référencé par un autre objet.
L’affectation entre plusieurs objets.

Alors, la présence d’un constructeur par recopie permet à chaque

objet d’avoir son propre emplacement dynamique.

La surdéfinition de l’opérateur d’affectation (b=a) consiste à :

La libération de l’emplacement pointé par b,
La création dynamique d’un nouvel emplacement dans lequel on
recopie les valeurs de l’emplacement pointé par a.
80
La recopie des valeurs des membres donnés non dynamique
 Surcharge de l’affectation
L'opérateur d'affectation est surchargé comme une fonction membre.

L’opérateur d'affectation stocke le résultat dans l'objet appelant et retourne une

référence sur cet objet.

Syntaxe de la surcharge de l’affectation dans une classe T:

class T {
int dim;
int *tab;
public:
T& operator=(const T&);
};
T& T::operator=(const T& t)
{
if(this!=&t)
{ dim=t.dim;
delete tab;
tab=new int[dim];
for(int i=0;i<dim;i++)tab[i]=t.tab[i];
}
return this;
}
On peut enchaîner des affectations :
81
T a, b, c;
a = b =c;
 Surcharge de l’opérateur d’indexation []:
Exemple
class vect
{int nelem;
float *val;
float & operator[](int) ;
};
float & vect:: operator [](int i)
{ if(i<0|| i>nelem) i=0;
Return val[i];
}
void main()
{ vect a(5), b(3),c(3);
cout<< c[1];//c.operator[](1);
for(int i=0;i<3;i++)b[i]=2*i;
}
82