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; }
Top Related