Leçon 2 : Surcharge des opérateurs

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

2. Leçon 2:Surcharge des opérateurs • La surcharge • Intérêt de la surcharge • Règles de surcharge • Opérateurs arithmétiques (classe vecteur) • Opérateurs de redirection de flux • Fonctions et classes amies

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

4. 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);

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

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

7. 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 IC void 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ées int t[max]; //tableau de max entiers };

8. Classe vecteur : implantation vecteur::vecteur(void){ taille=0; } int vecteur::getTaille(void){ return taille; } vecteur::vecteur (int t){ taille = t; }

9. Classe vecteur :implantation voidvecteur::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]; } }

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

11. 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 } voidvecteur::modifier(int i,int v){ t[i]=v; }

12. # include"vecteur.h" void main (void) { vecteur V1 (6); vecteur V2 (6); cin >> V1>>V2; ... cout << V1+V2 SURCHARGE des OPERATEURS BUT :Etendre la définition standard d ’un opérateur sur d’autres objets que ceux pour lesquels il est prédéfini. INTERÊTS : • Facilité d’écriture • Facilité de lecture • Lisibilité

13. # include"vecteur.h" void main (void) { vecteur V1 (6); vecteur V2 (6); cin >> V1>>V2; ... cout << V1+V2 SURCHARGE des OPERATEURS Exemples : • Opérations arithmétiques • Opérateur << • Opérateur >> • Opérateurs de comparaison • etc ...

14. Règles • Impossible de surcharger des opérateurs inconnus • Impossible de modifier l ’arité des opérateurs (exemple :+ est binaire) • Impossible de modifier les règles de priorité des opérateurs • Impossible 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

15. SURCHARGE de + Prototype retour operatorsymbole(paramètres) class X { public : X operator+ (const X& B); // est retourné IC+B };

16. 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;

17. 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]; };

18. 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; }

19. La classe rectangle fournit des méthodes Une application # include <iostream.h> # include "rectangle.h" void main (void) {rectangle R1,R2; } Opérateur >> Opérateur << Constructeur Méthode Surcharge des opérateurs >> et << cin >> R1 >> R2; cout << R1 << R2;

20. L ’instance cin de la classe istream déclenche l ’opérateur >> L ’instance cout de la classe ostream déclenche l ’opérateur << Opérateurs de redirection de flux Toute méthode est déclenchée par une instance # include <iostream.h> # include "rectangle.h" void main (void) {rectangle R; cin >> R; cout << R; ...

21. 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ésolution Déclarer la méthode de surcharge de l ’opérateur >> comme fonction amie de la classe rectangle.

22. Méthode amie Mécanisme : Lorsqu ’une méthode externe à une classeC 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.

23. EFFET Toutes les méthodes de la classe Y peuvent accéder à la section private de la classe X CLASSE AMIE class X { public : friend class Y; private : }; 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.

24. 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&

25. Rectangle à saisir Le premier argument est toujours une référence sur IC PROTOTYPE : opérateur >> class rectangle {public : //IC est de type istream friendistream& operator>>(istream& f,rectangle& R); // longueur et largeur de R sont saisies 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

26. 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; }

27. 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. # include <iostream.h> # include "vecteur.h" void main (void) { vecteur V(4); cin >> V;cout << V; } Exercice Coder une application permettant d ’exécuter la fonction main suivante