Leçon 2 : Surcharge des opérateurs

Leçon 2 : Surcharge des opérateurs

IUP 2 Génie Informatique

Méthode et Outils pour la Programmation

Françoise Greffier

Université de Franche-Comté

Leçon 2:Surcharge des opérateurs

La surchargeIntérêt de la surchargeRègles de surchargeOpérateurs arithmétiques (classe vecteur)Opérateurs de redirection de fluxFonctions et classes amies

Méthode surchargée

Le langage C++ permet la surcharge des méthodes, c’est à dire qu’il offre la possibilité d’implanter des méthodes ayant le même « nom ».

La signature d ’une méthode regroupe son nom et le type de ses paramètres.Le type retour ne fait pas partie de la signature d ’une méthode.

Méthode surchargée : exemple

Exemple d ’utilisation de la méthode :int i=power (2,3);double z=power(3.14,4);double z=power(2,3);

Méthode power surchargée :int power (int x, int y);double power (double x, double y);

Méthode surchargée : résolution

C’est la signature de la méthode qui permet au compilateur de sélectionner quelle méthode activer parmi celles surchargées.

Les critères de sélection intervenant dans la résolution de surcharge sont :

1) La portée de la classe de l’instance qui déclenche l’appel.

2) Le nombre d’arguments dans l’appel.3) La distance entre le type des arguments et celui des

paramètres correspondant.

CLASSE VECTEUR

On considère l ’objet : vecteur d ’entiers. Exemple : V = (2,5,1,4) V est un vecteur de 4 entiers.La dimension du vecteur a une valeur maximum égale à 10.

Classe vecteur : interface# include <iostream.h>const int max=10;class vecteur{public :

vecteur(void); // constructeur vecteur (int t);// const et initialisation de la taille int getTaille(void); // Sélecteur => taille de IC void saisir (void); //saisie de ICvoid afficher(void);//Affichage de IC vecteur add (const vecteur&);// Est retourné : IC + argument void modifier(int i,int v); // T[i] <- v ~vecteur (void)// destructeur

private : int taille; //nombre de cases réellement occupéesint t[max]; //tableau de max entiers

};

Classe vecteur : implantation

int vecteur::getTaille(void){ return taille;

}

vecteur::vecteur(void){ taille=0;

}

vecteur::vecteur (int t){ taille = t;

}

Classe vecteur : implantation

void vecteur::saisir (void){ if (taille==0){

int ta; cout << "\n Taille du vecteur :";

cin >> ta; if (ta <= max) taille = ta;

else taille=max;} for (int i=0; i<taille;i+=1){

cout<<"\n Valeur de l'élt No "<<i+1<< " : ";

cin >> t[i]; }}

Classe vecteur : implantation

void vecteur::afficher(void){for (int i=0; i<taille;i+=1){ int no=i+1; cout <<"\n"<< no <<" : "; cout << t[i]; }

}

Classe vecteur : implantation vecteur vecteur::add (const vecteur& v){ // IC + v vecteur somme; //appel du constructeur if (this->taille == v.taille){ somme.taille=this->taille; for (int i=0; i<this->taille;i+=1){ somme.t[i]=this->t[i]+v.t[i]; } } return (somme);//appel du construct par copie

}

void vecteur::modifier(int i,int v){ t[i]=v;

}

SURCHARGE des OPERATEURS

INTERÊTS :Facilité d’écritureFacilité de lectureLisibilité

BUT : Etendre la définition standard d ’un opérateur sur d’autres objets que ceux pour lesquels il est prédéfini.

cout << V1+V2

# include"vecteur.h"void main (void){ vecteur V1 (6); vecteur V2 (6); cin >> V1>>V2;

...

SURCHARGE des OPERATEURS

Exemples :Opérations arithmétiquesOpérateur <<Opérateur >>Opérateurs de comparaisonetc ...

# include"vecteur.h"void main (void){ vecteur V1 (6); vecteur V2 (6); cin >> V1>>V2;

...cout << V1+V2

RèglesImpossible de surcharger des opérateurs inconnusImpossible de modifier l ’arité des opérateurs (exemple :+ est binaire)Impossible de modifier les règles de priorité des opérateursImpossible de redéfinir les opérateurs prédéfinis sur des types reconnus par l ’opérateur.

Il faut respecter les règles syntaxiques prédéfinies

SURCHARGE de +Prototype retour operator symbole(paramètres)

class X{ public :

X operator + (const X& B);// est retourné IC+B

};

Surcharge de l ’opérateur +Toute méthode d ’une classe a un premier paramètre implicite représentant l ’instance courante.

La surcharge d ’un opérateur par une fonction membre d ’une classe, implique donc que le premier paramètre représente l ’instance courante.

Par conséquent l ’instance courante est toujours l ’opérande gauche des opérateurs binaires et l’unique opérande des opérateurs unaires.

Appel de l ’opérateur (notation) : I1.operator + (I2); <=> I1+I2;

Surcharge de l ’opérateur +

# include <iostream.h>class vecteur{public :vecteur operator + (const vecteur& B);// est retourné : IC+B

private :int taille;int t[max];

};

Surcharge de l ’opérateur +

vecteur vecteur:: operator + (const vecteur& B){vecteur somme;if (taille==B.taille){ somme.taille=taille;

for (int i=0; i<taille;i+=1)somme.t[i]=t[i]+B.t[i];

}return somme;}

Surcharge des opérateurs >> et <<

Opérateur >>

Constructeur

Méthode

La classe rectanglefournit des méthodes

Une application

# include <iostream.h> # include "rectangle.h"void main (void){rectangle R1,R2;

}

Opérateur <<cin >> R1 >> R2;cout << R1 << R2;

# include <iostream.h># include "rectangle.h"void main (void){rectangle R;cin >> R;

cout << R; ...

Toute méthode est déclenchée par une instance

Opérateurs de redirection de flux

L ’instance cin de la classe istream déclenche l ’opérateur >>

L ’instance coutde la classe ostream déclenche l ’opérateur <<

Problème d ’accessibilité

Problème Pour écrire : cin >> R;il faut que la classe istream puisse accéder à la section private de la classe rectangle.

RésolutionDéclarer la méthode de surcharge de l ’opérateur >>comme fonction amie de la classe rectangle.

Méthode amie

Mécanisme :Lorsqu ’une méthode externe à une classe C est déclarée amie dans la classe C, alors tous les membres de la classe C (y compris ceux de la section private) sont accessibles par la fonction externe.

Syntaxe :Qualificateur friend placé devant le prototype de la méthode externe à la classe.

CLASSE AMIE

class X{ public :

friend class Y;

private :

};

EFFET Toutes les méthodes de la classe Y peuventaccéder à la section privatede la classe X

C ’est moi : classe X qui définit qui sont mes ami(e)s, et donc qui ouvre l ’accès de ma section private à l ’extérieur.

PROTOTYPE : opérateur >>

class rectangle{public :friend istream& operator >> ( ???);

Dans la classe istream l ’opérateur >> retourne une référence sur le flux

Référence notée : istream&

PROTOTYPE : opérateur >>

class rectangle{public ://IC est de type istream friend istream& operator>>(istream& f,rectangle& R);// longueur et largeur de R sont saisies

Rectangleà saisir

Afin de pouvoir enchaîner les appels : cin >> R1 >> R2;l ’opérateur retourne une référence surle flux qu ’elle a reçu en premier argument

Le premier argument est toujours une référence sur IC

IMPLANTATION : opérateur >>

istream& operator>>(istream& flux,rectangle& R);{if (taille==0){ int ta; cout << "\n Taille du vecteur :";flux >> ta;if (ta <= max) taille = ta;

else taille=max;} for (int i=0; i<taille;i+=1){ cout<<"\n Valeur de l'élt No "<<i+1<< " : ";

flux >> t[i]; }

return flux;}

CLASSE VECTEUR

On considère l ’objet : vecteur d ’entiers. Exemple : V = (2,5,1,4) V est un vecteur de 4 entiers.La dimension du vecteur a une valeur maximum égale à 10.

ExerciceCoder une application permettant d ’exécuter la fonction main suivante

# include <iostream.h># include "vecteur.h"void main (void){ vecteur V(4); cin >> V; cout << V; }