7ième Classe (Mardi, 24 novembre) CSI2572

Devoir 3 ?

Votre examen est fait Après aujourd’hui, vous aurez vu tous ce dont vous avez besoin pour avoir 100% Après aujourd’hui, on fera de la revue. De la revue. De la revue.

H Nous avions vu que les opérateurs en C++ peuvent être redéfinis (surchargés) H Surcharger un opérateur consiste à en définir le comportement tel qu'il s'applique à un objet. Surcharge d'opérateur ++

class point { private : float abscisse, ordonnee; public : point(); point(float,float); void afficher (); point operator + (point); float operator * (point); }; point point::operator +(point p){ point resultat; resultat.abscisse = abscisse + p.abscisse; resultat.ordonnee = ordonnee + p.ordonnee; return resultat; } float point::operator *(point p){ return (abscisse * p.abscisse + ordonnee * p.ordonnee); }

Nous avions aussi vu que avec ce type de surcharge p1 + p2; est équivalent à: p1.operator +(p2); C'est la méthode de l'instance de gauche qui est appelée. Donc, si on définit: point point::operator +(int x){ point resultat; resultat.abscisse = abscisse + x; resultat.ordonnee = ordonnee; return resultat; } L'appel suivant est légal: p1 + 3; Mais celui ci ne l'est pas: 3 + p1; Surcharge d'opérateur++

faire ca: 3 + p1; On peut. Le mot clé friend permet de déclarer une fonction ou une classe avec les droits d'accès complets aux membres privés et protégés de la classe, sans être un membre de cette classe. On aimerait bien pouvoir…

class point{ private : float abscisse, ordonnee; public : … point operator + (point); friend point operator + (int, point); }; point point::operator +(point p){ point resultat; resultat.abscisse = abscisse + p.abscisse; resultat.ordonnee = ordonnee + p.ordonnee; return resultat; } point operator +(int x, point p){ return p + x; }

H Lorsqu’on définit un opérateur pour une classe, on ne sait pas forcément très bien comment le déclarer. En particulier, faut-il en faire une fonction membre, ou une fonction amie ? Et quels arguments doivent être passés en référence ? H Il n’y a pas de réponse générale à ce problème, mais un certain nombre de règles simples que l’on peut suivre, quoiqu’elles n’aient rien d’obligatoire. H Si l’opérateur demande parmi ses arguments une valeur modifiable (lvalue), il est préférable d’en faire une méthode, afin d’éviter des écritures étranges. C’est ce que nous avons fait pour l’opérateur d’affectation, dont le premier argument est une valeur modifiable pour éviter certaines possibilités. Par exemple: Famille ou Ami ?

class fraction { long num, den; // numérateur, dénominateur public : fraction(long numer, long denom = 1) { num = numer; den = denom; } friend fraction& operator=(fraction, fraction); }; fraction& operator=(fraction& f1, fraction f2){ f1.num = f2.num; f1.den = f2.den; return f1; }

fraction f(2/5) ; 4 = f ; Pourquoi ? L'instruction aurait pour effet de créer un objet temporaire de valeur 4/1, y recopier 2/5, puis à le détruire : il n’y aurait donc aucun effet. Le moins que l’on en puisse dire c’est que ce n’est guère naturel. Si l’on a par contre défini un tel opérateur comme un membre, cette écriture devient interdite parce que le compilateur ne fait pas de conversion de type pour les instances qui appellent un membre. Pourrait permettre:

friend permet de régler le mode d'accès en le mettant public pour certains objets appelants et privé pour d'autres. Il y a trois niveaux: C On peut autoriser l'accès à une fonction particulière, définie n'importe où dans le programme. C On peut limiter l'accès à une classe extérieure déterminée. C On peut limiter l'accès à une fonction particulière d'une classe extérieure déterminée. Toujours besoin de friend

H Dans l'exemple suivant, la classe A déclare la classe B amie. La classe B pourra utiliser les membres de A. H La classe B doit être déclarée après la classe A pour que le compilateur connaisse les membres de A dans B. H Cependant il faut faire précéder A d'une déclaration provisoire avancée de B car B dans la déclaration de A. La déclaration avancée est faite sur la 1ère ligne. Toujours besoin de friend

class B; class A { private: int a; f(); friend B; }; class B { void h (A*p) { p->a = 0; p->f(); } };

H Dans l'exemple suivant, le mot-clé friend permet de définir la forme d'une fonction dont le corps peut être défini en n'importe quel point du programme. H Le corps de la fonction est défini plus loin sans faire précéder son nom du nom de la classe. Les instructions de cette fonction peuvent cependant atteindre tous les membres de la classe même si ceux-ci ne sont pas publics. Toujours besoin de friend

class X { int a; friend void f ( X* ); }; void f (X * p) { p->a = 0; } void main () { X * ptr = new X; f (ptr); }

H Il est possible de restreindre la propriété friend à une seule fonction d'une classe. Dans ce cas, seules les instructions de la fonction f() de la classe B pourront atteindre les éléments de la classe A. Toujours besoin de friend

class B; class A{ private: int a; friend void B :: f(); }; class B { void f(A * p) { p->a = o; } };

Préprocesseur: H Nous connaissons déja la directive #include qui permet d'inclure des fichiers header. H Comment empécher d'inclure les même header plusieurs fois ? H On peut utiliser les directives #ifndef, #define, #endif

#ifndef (SOME_MARKER) #define SOME_MARKER... #ifndef (STRING_H) #include "String.h" #endif... #endif

H Il peut arriver que l’on souhaite qu’une donnée soit partagée par toutes les instances de la classe. pour cela, il suffit de déclarer le champ comme statique, avec le mot clé static. Membres statiques

class Flower { protected: int nectar; public: Flower(int i=5):nectar(i) { } int give_nectar() { if (nectar>0) { nectar--; return 1; } return 0; } int empty() { return nectar == 0; } void assess_capacity(char* name) { cout << name << " has " << nectar << " amount of " << "nectar left" << endl; } };

class Bee { protected: static Flower* F; int bucket; int capacity; public: Bee(int i=5):bucket(0),capacity(i) { } void collect() { if ( bucket < capacity) { bucket += F->give_nectar(); } } int full() { return bucket == capacity;} static void Send_to_flower(Flower *f) { F = f; } void assess_performance(const char * name) { cout << name << " collected " << bucket << " amount of nectar " << "and his bucket is " << (full()?"full":"not full") << endl; } };