Vous êtes sur la page 1sur 25

POO – Langage C++

Les fonctions amies


Surcharge/Surdéfinition des
opérateurs (PARTIE 2)
1ère année ingénieur informatique

Mme Wiem Yaiche Elleuch

1
2013 - 2014
Surcharge de l'opérateur d'addition
(operator+)
• Surcharge en tant que fonction membre
– point operator+(point); // cas1
– int operator+(point); // cas2
– void operator+(point); // cas3
• Surchage en tant que fonction indépendante

Mme Wiem Yaiche Elleuch 2


Surcharge operator+en tant que fonction
membre: cas1

Mme Wiem Yaiche Elleuch 3


Surcharge operator+en tant que fonction
membre: cas2

Mme Wiem Yaiche Elleuch 4


Surcharge operator+en tant que fonction
membre: cas3

Mme Wiem Yaiche Elleuch 5


Surcharge operator+ en tant que
fonction indépendante

Mme Wiem Yaiche Elleuch 6


Surcharge des opérateurs +, -, ==, <=

Mme Wiem Yaiche Elleuch 7


Exemples

Mme Wiem Yaiche Elleuch 8


Surcharge des opérateurs == et <=

Mme Wiem Yaiche Elleuch 9


Surcharge de l'opérateur -

Mme Wiem Yaiche Elleuch 10


Surcharge de operator[]

Mme Wiem Yaiche Elleuch 11


Remarques
• Il est possible de surdéfinir l'opérateur [] de manière que
a[i] désigne l'élément d'emplacement i de a.

• C++ impose de surdéfinir cet opérateur sous la forme d'une


fonction membre

• C++ interdit de définir l'opérateur [] sous la forme d'une


fonction amie;

• il en allait déjà de même pour l'opérateur =


12
Problèmes rencontrés lorsque l'objet contient
un pointeur vers une partie dynamique
PROBLEME: copie superficielle SOLUTION: copie profonde

Cas problème solution


Affectation de deux objets Objets dépendants Surdéfinition de l'opérateur
(partagent la même partie d'affectation =
dynamique)
Initialisation d'un objet lors Objets dépendants Constructeur de recopie
de sa déclaration (partagent la même partie
dynamique)
Passage d'un objet par Libération de la partie Constructeur de recopie
valeur en argument d'une dynamique de l'objet à la
fonction sortie de la fonction

Objet retourné par une Libération de la partie Constructeur de recopie 13

fonction dynamique de l'objet à la


sortie de la fonction
surcharge de l'opérateur d'affectation:
operator=

nomClasse & operator= (const nomClasse& w)


{
if(this !=&w) // b=b;
{
// copier les valeurs
// libération ancien espace mémoire
// allocation nouvel espace
//copie des valeurs dans le nouvel espace

}
return *this;
} 14
Sucharge de l'opérateur d'affectation
(operator=) de la classe etudiant

Mme Wiem Yaiche Elleuch 15


Sucharge de l'opérateur d'affectation
(operator=) de la classe etudiant

Mme Wiem Yaiche Elleuch 16


Surcharge des opérateurs <<, >> et =
de la classe courbe

Mme Wiem Yaiche Elleuch 17


Surcharge de l'opérateur >> de la
classe courbe

Mme Wiem Yaiche Elleuch 18


Surcharge de l'opérateur << de la
classe courbe

Mme Wiem Yaiche Elleuch 19


Surcharge de l'opérateur = de la classe
courbe

Mme Wiem Yaiche Elleuch 20


Forme canonique de coplien d'une classe

• La forme canonique, dite de Coplien, fournit un cadre de base


à respecter pour les classes dont certains attributs sont alloués
dynamiquement.
class T
{
public:
T(…..); // constructeur pour l'allocation des parties dynamiques de l'objet
T(const T&); // constructeur de recopie
~T(); //destructeur pour la libération des parties dynamiques de l'objet
T& operator= (const T &); // affectation
……
21
};
Surcharge de l'opérateur d'affectation dans une
classe dérivée

Mme Wiem Yaiche Elleuch


22
Mme Wiem Yaiche Elleuch 23
Appel de operator<< de la classe etudiant pour afficher
nb_notes et les notes

Mme Wiem Yaiche Elleuch


24

Appel de operator>> de la classe etudiant pour saisir nb_notes et les notes


class T Formes canoniques de la classe de base T et de la classe dérivée U
{ …. • U est sous classe de T
•T et U possèdent chacune des parties dynamiques
public:
T (...) ; / / constructeurs
T (const T &) ; / / constructeur de recopie de T
~T () ; / / destructeur
T & operator = (const T &) ; / / operateur d'affectation

};
class U : public T
{ public:
U (...) ; / / constructeurs
U (const U & x) : T (x) // constructeur recopie de U : utilise celui de T
{ prévoir ici la copie de la partie spécifique à U
}
~U();
U & operator= (U & w) //opérateur d'affectation
{ T * ad1 = this;
T * ad2 = &w ;
25
*ad1 = *ad2 ; // affectation de la partie spécifique à T
// prévoir ici l'affectation de la partie spécifique à U
}}