POO - Laborator intermediar 4-5 Supradefinirea operatorilor

I. De ce se supradefinesc operatorii ?

Functiile operator constituie un tip special de functii. Sunt utilizate pentru redefinirea operatorilor si pentru alte tipuri de date (definite de utilizator) in afara celor de baza. O clasa se poate defini mpreuna cu un set de operatori asociati, obtinuti prin suprancarcarea operatorilor existenti. In acest fel, se efectueaza operatii specifice noului tip, la fel de simplu ca n cazul tipurilor standard. Procedeul consta n definirea unei functii cu numele operator < simbol > II. Ce operatori se pot supradefinii ? Toti operatorii pot fi supradefiniti cu urmatoarele cateva exceptii : ., ::, ? : , sizeof . III. Dupa ce reguli se realizeaza supradefinirea ?

1. Se pot supradefini in numai operatori existenti, deci simbolul asociat functiei operator trebuie
sa fie deja definit ca operator pentru tipurile standard (nu e permisa introducerea unor simboluri noi de operatori).

2.

Nu se pot modifica: pluralitatea (un operator unar nu poate fi supradefinit ca unul binar sau invers) precedenta asociativitatea.

3. Functia operator trebuie sa aiba cel putin un parametru de tipul clasa caruia ii este asociat operatorul respectiv. Aceasta restrictie implica faptul ca supradefinirea operatorilor e posibila numai pentru tipurile clasa definite in program, pentru tipurile standard operatorii isi pastreaza definitia. 4. Pentru a putea fi implementata ca functie membru, functia operator trebuie sa aibe ca prim parametru un obiect de tipul clasei. 5. Functiile operator pot fi implementate ca si functii membre ale clasei sau ca si functii prietene ale clasei, atunci cand este necesar (exemplu cazul operatorului de afisare). In particular, pentru operatorii: = ,[], (), -> functia operator trebuie sa fie membra a clasei. Observatii : - Este indicat ca orice clasa sa defineasca propriul operator de atribuire, deci lucrurile sa nu fie lasate a fi tratate implicit de compilator - cu atat mai mult daca are campuri de tip pointer. - Pentru un operator binar op, expresia x op y este interpretata: x.operator op(y); // functie membra sau 1

operator op(x,y); // functie friend - Pentru un operator unar op, expresia x op sau op x este interpretata: x.operator op(); // functie membra sau operator op(x); // functie friend. ----------------------------Laboratorul 5-------------------------------------------------------------

#include <iostream> #include <cmath> using namespace std; class complex { private: float real; float imag;

public: complex() // constructor fara parametrii { real = 0; imag = 0; } complex(float r/*=0.0f*/,float im/*=0.0f*/) // constructor cu parametrii { real = r; imag = im; } complex(const complex& c)// constructor de copiere { real = c.real; imag = c.imag; } complex getconjugat()//calculeaza conjugatul { complex a(real,(-1) * imag); return a; } float getmodul()//calculeaza modulul { return sqrt(real*real + imag*imag); } void setdata(float a,float b)//modifica valoarile partii reale si imaginare
2

{ real = a; imag = b; } float getreal()//returneaza partea reala { return real; } float getimaginar()//returneaza partea imaginara { return imag; } bool operator ==(const complex c)//supradefinire operator de egalitate { if (real == c.real && imag == c.imag) return true; else return false; } bool operator !=(const complex c)// supradefinire operator diferit { if (real == c.real && imag == c.imag) return false; else return true; } complex& operator =(const complex c)// supradefinire operator de atribuire { real = c.real; imag = c.imag; return *this; } //se intoarce referinta la complex pt ca sa pot face op de genul : int a,b,c,d ; a=(b=(c=(d=4))) ; //asociativitate la dreapta friend complex operator +(const complex a, const complex b) { complex c; c.real = a.real + b.real; c.imag = a.imag + b.imag; return c; } // supradefinire operator adunare
3

//operanzii sunt declarati const ca sa nu poata fi modificati

friend complex operator -(const complex a, const complex b) { complex c; c.real = a.real - b.real; c.imag = a.imag - b.imag; return c; } friend complex operator -(const complex b) //ex d=- e; { complex c; c.setdata(-b.real,-b.imag); return c; } friend complex operator *( const complex a, const complex b) { complex c; c.real = a.real*b.real - a.imag*b.imag; c.imag = a.imag*b.real - a.real*b.imag; return c; } friend complex operator /( const complex a, const complex b) { complex c; c.real = (a.real * b.real + a.imag * b.imag) / ((a.imag*a.imag)+(b.imag*b.imag)); c.imag = (a.imag * b.real - a.real * b.imag) / ((a.imag*a.imag)+(b.imag*b.imag)); return c; } complex& operator +=(complex a) // supradefinire operato r incrementare cu o valoare { real += a.real; imag += a.imag; return *this; } //se intoarce referinta la complex pt a putea face operatii ca : int m ; (m+=5)+=3 ; complex& operator -=(complex a) { real -= a.real; imag -= a.imag; return *this; }
4

complex& operator *=(complex a) { real = a.real*real - a.imag*imag; imag = a.imag*real - a.real*imag; return *this; } complex& operator /=(complex a) { real = (a.real * real + a.imag * imag) / ((a.imag*a.imag)+(imag*imag)); imag = (a.imag * real - a.real * imag) / ((a.imag*a.imag)+(imag*imag)); return *this; } complex& operator /=(float a) { real /= a; imag /= a; return *this; } friend ostream& operator <<(ostream &s,complex &c)// supradefinire operator afisare { s<<c.real<<" + i*"<<c.imag; return s; } };
int main() { complex d(2,1); complex c(d); complex a = d - c; a = -d; cout<<a<<endl; a *= d; cout<<a<<endl; a += c; cout<<a<<endl; a /= d; cout<<a<<endl; a = d+c; cout<<a<<endl; a = d*c; cout<<a<<endl; 5

a = d/c; cout<<a<<endl; a -= d; cout<<a<<endl; a /= 4; cout<<a<<endl; cout<<d.getmodul()<<endl; d.setdata(2,2); cout<<d.getreal()<<" "<<d.getimaginar()<<endl; getch(); return 0; }