Overloading di operatori In C++ è possibile effettuare l overloading degli operatori per utilizzarli sugli oggetti delle classi definite dagli utenti complex.h class Complex { double m_re, m_im; public : Complex(double re, double im) : m_re(re), m_im(im) { // ; #include complex.h void main { Complex c1(1, 2), c2(3,4); Complex c3 = c1 + c2; ridefinizione di + Obiettivo: scrivere le espressioni in cui compaiono gli oggetti con la stessa concisione delle espressioni in cui compaiono i tipi predefiniti Laboratorio di Informatica Antonio Monteleone 69
Overloading di operatori (2) Permette di utilizzare tipi definiti dall utente come se fossero tipi fondamentali E possibile effettuare l overloading di qualunque operatore ad eccezione di..* ::? sizeof La cardinalità, l associatività e la precedenza di un operatore non possono essere modificati Non è possibile creare nuovi operatori ma solo ridefinire quelli esistenti L overloading di un operatore è effettuato mediante la definizione di una funzione operatore Laboratorio di Informatica Antonio Monteleone 70
Overloading di operatori (3) Le funzioni operatore possono essere implementate come Funzioni membro tipo_di_ritorno nome_classe::operator op(argomenti) op è l operatore da ridefinire Funzioni non membro tipo_di_ritorno operator op(argomenti) Non sempre è possibile ridefinire un operatore come f. membro #include <iostream> #include complex.h void main { Complex c1(1, 2); cout << c1; // operando sx non di tipo Complex no f. membro ostream & operator << (ostream & os, const Complex &c); Laboratorio di Informatica Antonio Monteleone 71
Operatori unari sono implementati come metodi senza argomenti (l oggetto è l argomento implicito) class Date { public: Date(int d, int m, int y); Date & operator++(); //preincr. ; Overloading di operatori (4) funzioni friend a un solo argomento void main() { Date d(12,03,2002); ++d; // d.operator++(); class Date { public: Date(int d, int m, int y); friend Date & operator++(date &); ; Date & operator++(date &); void main() { Date d(12,03,2002); ++d; // operator++(d); Laboratorio di Informatica Antonio Monteleone 72
Overloading di operatori (5) Operatori binari possono essere implementati come metodi con un argomento (il primo argomento, implicito, è l oggetto il cui operatore agisce) class Complex { double m_re, m_im; public: Complex(double re, double im); const Complex operator+(const Complex & c) { return Complex(m_re + c.m_re, m_im + c.m_im); ; funzioni friend a due argomenti. class Complex { public: Complex(double re, double im); friend const Complex operator+( const Complex &c1, const Complex &c2); ; const Complex operator+(const Complex & c1, const Complex &c2); Laboratorio di Informatica Antonio Monteleone 73
friend La parola chiave friend può essere usata per permettere che una certa funzione o classe abbia libero accesso ai dati privati della classe class A { private: int m_x; friend int fun(const A &); friend void C::f(int); ; class B { private: int m_y; friend class C; ; class C { void f(int i); void g(); ; int fun(const A & a) { return a.m_x; // OK perché friend void C::f(int i) { A a; a.m_x = i*10; // OK perché friend void C::g() { A a; a.m_x = 12; //errore: g non è friend Laboratorio di Informatica Antonio Monteleone 74
friend (2) friend e` nemico dell incapsulamento e quindi dell OOP Un uso eccessivo di friend è quasi sempre sintomo di un cattivo disegno Esistono però situazioni in cui l uso di friend può essere accettabile Overloading di operatori binari Considerazioni di efficienza Relazione speciale fra due classi Laboratorio di Informatica Antonio Monteleone 75
Ogni oggetto puo accedere al proprio indirizzo tramite un puntatore di nome this Il valore di this non puo essere cambiato this per una classe A il tipo di this e A* const o const A* const E particolarmente utile quando si definisce un operatore di assegnazione (=) o, in generale, quando si vuole restituire una copia o un riferimento all oggetto stesso class Time { public: Time(int h, int m, int s); Time & sethour(int h); Time & setmin(int m); private: int hh, mm, ss; ; void main(){ Time t(12,03,58); t.sethour(11).setmin(8); Time & Time::setHour(int h) { hh = (h>0 && h <24)? h : 0; return *this; Laboratorio di Informatica Antonio Monteleone 76
L overload dell operatore di assegnazione L operatore di assegnazione e un operatore binario invocato dal compilatore quando compare un istruzione di assegnazione fra variabili non utilizzata per inizializzare un oggetto class MyClass {/*..*/; void main() { MyClass b; MyClass a = b; // costruttore di copia a = b; // a.operator=(b); In assenza di overload, il compilatore crea una versione di default di tale operatore che effettua una copia degli oggetti membro a membro Laboratorio di Informatica Antonio Monteleone 77
L overload dell operatore di assegnazione (2) Una classe che ha dei membri di tipo puntatore deve sempre ridefinire l operatore = In assenza di overload, dopo l assegnazione la memoria puntata prima dell assegnazione dalla variabile puntatore dell operando sinistro non e piu accessibile i due oggetti hanno un puntatore alla stessa area di memoria L overload dell operatore = permette di eseguire la copia dell area puntata e non del puntatore. La memoria precedentemente puntata dall operando sinistro deve comunque essere deallocata e nuova memoria deve essere allocata Laboratorio di Informatica Antonio Monteleone 78
L overload dell operatore di assegnazione (3) Senza overload di = class IVector { public: IVector(int len=100):m_len(len) void main() { { /* */ IVector v1(10), v2(20); ~IVector() {/* */ v2 = v1; /* */ for (int i=0; i<v1.size(); ++i) int & operator [] (int i) { v1[i] = i; // v2[i]==i! assert(i>0 && i<m_len); // crash! return m_data[i] IVector & operator(const IVector &); Soluzione: overload di = private: int m_len; int *m_data; ; IVector & IVector::operator=(const IVector &src) { if (this == &src) return *this; if (m_data) delete [] m_data; m_len = src.m_len m_data = new int[m_len]; for (int i=0; i<m_len; ++i) m_data[i] = src.m_data[i]; return *this; Laboratorio di Informatica Antonio Monteleone 79
Overload degli operatori di I/O su stream Gli operatori << e >> possono essere ridefiniti per consentire operazioni del tipo: IVector v(10); for (int i=0; i<v.size(); ++i) v[i] = i; cout << Il vettore v vale << v << endl; Si utilizza una funzione friend: class IVector { friend ostream& operator<<(ostream& os, const IVector &v); /* */ ; ostream& operator <<(ostream& os, const IVector & v){ for (int i=0; i<v.size(); ++i) os << v[i] <<, ; return os ; // consente di scrivere cout << v1 << v2 Laboratorio di Informatica Antonio Monteleone 80
Sul valore di ritorno degli operatori Nell overloading degli operatori ci sono dei casi in cui è necessario restituire un oggetto per valore e altri in cui è necessario restituirlo per riferimento. T operator+(const T &a, const T &b); T &T::operator=(const T &rhs); E anche opportuno restituire un oggetto costante ogni volta questo è possibile. const T operator+(const T &a, const T &b); Laboratorio di Informatica Antonio Monteleone 81
#include point.h #include <iostream> using namespace std; using namespace labinfo; int main() { Point a(1,2), b(2,3); cout << (a += b); assert(a == Point(3, 5)); Sul valore di ritorno degli operatori Point c, d; c = d = b; // c = (d = b) o c.operator=(d.operator=(b)); assert(c == Point(2, 3)); (c = a).x = 10; // il valore di ritorno di operator= deve essere Point & assert(c.x == 10); cout << (d += a + b); assert(d == Point(7, 11)); Laboratorio di Informatica Antonio Monteleone 82
// continua il main Sul valore di ritorno degli operatori (d += a + b) += a; assert(d == Point(15, 24)); // (a + b).rotate(0.5); // errore se a + b restituisce un const Point e // Point::rotate non è const assert(a!= b); // (-a).rotate(b, 11); // errore se -a restituisce un const Point e // Point::rotate non è const // end of main Laboratorio di Informatica Antonio Monteleone 83
// point.h #include <cmath> namespace labinfo { Sul valore di ritorno degli operatori class Point { public: Point(double _x=0, double _y=0) : x(_x), y(_y) {; inline Point& operator+=(const Point &a) { x+=a.x; y+=a.y; return *this; inline Point& operator-=(const Point &a) { x-=a.x; y-=a.y; return *this; inline void rotate(const Point &p, double alpha) { x = (x-p.x)*cos(alpha) - (y-p.y)*sin(alpha) + p.x; y = (x-p.x)*sin(alpha) + (y-p.y)*cos(alpha) + p.y; inline void scale(double a, double b) { x *= a; y *= b; inline void scale(double a) { scale(a,a); double x, y; ; Laboratorio di Informatica Antonio Monteleone 84
Sul valore di ritorno degli operatori //------------------------------------------------------ inline const Point operator+(const Point &a, Point &b) { return Point(a)+=b; inline const Point operator-(const Point &a, Point &b) { return Point(a)-=b; ; inline const Point operator-(const Point &a) { return Point(-a.x,-a.y); //------------------------------------------------------- inline double operator*(const Point &a, const Point &b) { return a.x*b.x+a.y*b.y; //------------------------------------------------------- inline ostream & operator<<(ostream &out, Point &p) { return out << "(" << p.x << ", " << p.y << ")"; Laboratorio di Informatica Antonio Monteleone 85
Sul valore di ritorno degli operatori //------------------------------------------------------- inline const Point operator*(int a, const Point &p) { return Point(a*p.x,a*p.y); //------------------------------------------------------- inline const Point operator*(const Point &p, int a) { return Point(a*p.x,a*p.y); //------------------------------------------------------- inline bool operator==(const Point &p1, const Point &p2) { return (p1.x == p2.x && p1.y == p2.y); //------------------------------------------------------- bool operator!=(const Point &p1, const Point &p2) { return!(p1 == p2); // namespace labinfo Laboratorio di Informatica Antonio Monteleone 86
Sul valore di ritorno degli operatori Conclusioni: Ogniqualvolta una funzione operatore produce un nuovo oggetto questi deve essere restituito per valore. Se l oggetto restituito deve essere utilizzato solo come l-value allora conviene renderlo anche costante. Se l oggetto restituito deve essere utilizzato come r-value ( lo si deve modificare) allora questi deve essere restituito come riferimento (all oggetto su cui la funzione operatore è invocata). Laboratorio di Informatica Antonio Monteleone 87
Considerazioni su op= e op Potendo scrivere a = a + b; ci si potrebbe aspettare di poter scrivere anche a += b; Per i tipo definiti dall'utente non esiste nessuna relazione implicita tra operator= e operator+= e per poterli utilizzare entrambi è necessario definirli entrambi. Laboratorio di Informatica Antonio Monteleone 88
class Integer { public: Integer(int i) : m_value(i) { Integer &operator+=(const Integer &i) { m_value += i.m_value; return *this; bool operator==(const Integer &rhs) { return m_value == rhs.m_value; // int m_value; ; Considerazioni su op= e op E possibile implementare operator+ in termini di operator+= const Integer operator+(const Integer &a, const Integer &b) { return Integer(a) += b; La presenza di un oggetto senza nome facilita la Return Value Optimization (RVO) Laboratorio di Informatica Antonio Monteleone 89
Considerazioni su op= e op E' possibile rendere generica l implementazione di operator@ in termini di operator@= // math_ops.h // altre funzioni operatore template<typename T> const T operator+(const T & a, const T & b) { return T(a)+=b; template<typename T> const T operator-(const T & a, const T & b) { return T(a)-=b; // altre funzioni operatore La semplice inclusione di math_ops.h rende disponibile operator@ per le classi che definiscono operator@= (con @ uguale a +,-,*, ) In generale la versione op= di un operatore è sempre più efficiente della op Laboratorio di Informatica Antonio Monteleone 90
Operatori di incremento e decremento Gli operatori di incremento e decremento sono disponibili sia nella forma prefissa che in quella post-fissa. class Time { public: Time(int h=0, int m=0, int s=0) :m_h(h%24), m_m(m%60), m_s(s%60) { int gethour() { return m_h; int getmin () { return m_m; int getsec () { return m_s; void sethour(int h) { m_h = h%24; void setmin (int m) { m_m = m%60; void setsec (int s) { m_s = s%60; Time & operator++(); // incremento prefisso const Time operator++(int); // incremento post-fisso bool operator==(const Time &t) const; void print(ostream &os) const; private: int m_h, m_m, m_s; ; Laboratorio di Informatica Antonio Monteleone 91
Operatori di incremento e decremento ostream & operator <<(ostream &os, const Time &t) { t.print(os); return os; // ----- incremento pre-fisso Time & Time::operator++() { m_s = (++m_s) % 60; if (m_s == 0) { m_m = (++m_m) % 60; if (m_m == 0) m_h = (++m_h) % 24; return *this; // ---- incremento post-fisso const Time Time::operator++(int) { Time old = *this; ++(*this); return old; Laboratorio di Informatica Antonio Monteleone 92
Operatori di incremento e decremento bool Time::operator==(const Time &t) const { return m_h == t.m_h && m_m == t.m_m && m_s == t.m_s; Nell uso della class Time Time time(10, 12, 55); ++time; // viene chiamato time.operator++() time++; // viene chiamato time.operator++(0) Con un tipo predefinito è possibile effettuare un doppio incremento prefisso int i = 10; ++++i; // dopo il doppio incremento prefisso i vale 12 Time time(10, 12, 55); ++++time; // time.operator++().operator++() assert(time == Time(10, 12, 57); Affinché il doppio incremento modifichi l'oggetto a cui è applicato e' necessario che l'operatore di incremento prefisso restituisca un riferimento a tale oggetto. Laboratorio di Informatica Antonio Monteleone 93
Operatori di incremento e decremento Per il doppio incremento post-fisso int i = 10; i++++; // tale espressione è sintatticamente sbagliata Leggendo tale espressione ci si aspetta un doppio incremento del valore di i. In realtà il valore dell'espressione i++ è il valore di i prima del primo incremento. Il secondo incremento agirebbe su tale valore e alla fine i sarebbe incrementato solo una volta e non due come ci si potrebbe aspettare. Per evitare ogni confusione il compilatore considera errata tale espressione. Laboratorio di Informatica Antonio Monteleone 94
Operatori di incremento e decremento Nell'overloading di un operatore è opportuno essere consistenti col comportamento dello stesso operatore sui tipi predefiniti. Per evitare che espressioni del tipo Time time(10, 12, 55); time++++; // time.operator++(0).operator++(0) siano considerate lecite è sufficiente che l'operatore di incremento post-fisso restituisca un oggetto costante (su un oggetto costante si possono invocare solo funzioni membro costanti) Raccomandazione: Quando possibile è sempre meglio utilizzare la forma prefissa di un operatore di incremento/decremento poiché tale forma evita la costruzione e la successiva distruzione di un oggetto temporaneo Laboratorio di Informatica Antonio Monteleone 95
Operatori di conversione In C e C++ il compilatore può eseguire dei cast impliciti da un tipo a un altro. void f1(double d) { void f2() { int i=10; f1(i); // promozione da int a double Le conversioni implicite tra tipi possono coinvolgere operatori di conversione definiti dall utente. class MyClass1 { public: // operator dst_type ( ); ; void f(){ MyClass1 cc; dst_type aa = cc; // conversione da MyClass1 a dst_type Laboratorio di Informatica Antonio Monteleone 96
Operatori di conversione Le conversioni implicite tra tipi possono coinvolgere costruttori con un solo argomento che di fatto agiscono come operatori di conversione class MyClass2 { public: MyClass2(int a); // ; void f(){ MyClass2 cc; cc = 10; // conversione da int a MyClass2 Anche se tali operatori di conversione possono rivelarsi utile, è opportuno utilizzarli con molta cautela. Laboratorio di Informatica Antonio Monteleone 97
Operatori di conversione template <typename T> class ASmartPointer { public: ASmartPointer(T *pointer=0) : m_pointer(pointer) { ~ASmartPointer() { delete m_pointer; T *operator->() { return m_pointer; T &operator*() { return *m_pointer; operator bool () { return m_pointer!= 0; private: ASmartPointer(const ASmartPointer &); void operator=(const ASmartPointer &); T *m_pointer; ; void testasmartpointer() { ASmartPointer<Point> sp1(new Point(1,1)); ASmartPointer<Point> sp2(new Point(2,2)); if (sp1 == sp2) cout << "non e' come sembra" << endl; Laboratorio di Informatica Antonio Monteleone 98
Operatori di conversione class IntArray { public: IntArray(int n) : m_size(n), m_array(new int [n]) { IntArray(const IntArray &rhs) { //... ~IntArray() { delete [] m_array; IntArray &operator=(const IntArray &rhs) { //... return *this; int & operator[] (int i) { return m_array[i]; private: int m_size; int *m_array; ; void testintarray() { IntArray ia(6); for (int i=0; i<6; ++i) ia[i] = i; ia = 5; // un errore di battitura // a ia viene assegnato un IntArray di 5 // elementi Laboratorio di Informatica Antonio Monteleone 99
Operatori di conversione E possibile impedire una conversione implicita di tipo attraverso un costruttore mediante l uso della parola chiave explicit class IntArray { public: explicit IntArray(int n) : m_size(n), m_array(new int [n]) { IntArray(const IntArray &rhs) { //... ~IntArray() { delete [] m_array; IntArray &operator=(const IntArray &rhs) { //... //... private: int m_size; int *m_array; ; void testintarray() { IntArray ia(6); for (int i=0; i<6; ++i) ia[i] = i; ia = 5; // grazie a explicit non compila Laboratorio di Informatica Antonio Monteleone 100