Vous êtes sur la page 1sur 82

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

Vous aimerez peut-être aussi