La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

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

Présentations similaires


Présentation au sujet: "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é."— Transcription de la présentation:

1

2 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é

3 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

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

5 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);

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

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

8 Classe vecteur : interface # include 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 };

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

10 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> t[i]; } }

11 Classe vecteur : implantation void vecteur::afficher(void){ for (int i=0; i

12 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 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; }

13 SURCHARGE des OPERATEURS INTERÊTS : Facilité d’écriture Facilité de lecture Lisibilité 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;...

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

15 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

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

17 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;

18 Surcharge de l ’opérateur + # include class vecteur{ public : vecteur operator + (const vecteur& B); // est retourné : IC+B private : int taille; int t[max]; };

19 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

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

21 # include # 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 cout de la classe ostream déclenche l ’opérateur <<

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

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

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

25 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&

26 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 sur le flux qu ’elle a reçu en premier argument Le premier argument est toujours une référence sur IC

27 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> t[i]; } return flux; }

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


Télécharger ppt "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é."

Présentations similaires


Annonces Google