Obsługa i przeciążanie operatorów klas

Autor podstrony: Krzysztof Zajączkowski

Stronę tą wyświetlono już: 6053 razy

Lista operatorów możliwych do przeciążenia

Poniżej zamieszczam listę operatorów, które można przeciążać:

  1. + operator ten może przyjmować jeden lub dwa argumenty;
  2. - operator ten może przyjmować jeden lub dwa argumenty;
  3. * mnożenie;
  4. / dzielenie;
  5. % dzielenie modulo;
  6. ^ operator bitowej alternatywy wykluczającej XOR;
  7. & dwuarguumentowy operator bitowej koniunkcji AND, lub jednoargumentowy operator uzyskania adresu;
  8. | operator bitowej alternatywy OR;
  9. ~ operator negacji bitowej jednoargumentowy;
  10. ! operator negacji wartości NOT;
  11. = operator podstawienia;
  12. < mniejsze niż;
  13. > większe niż;
  14. += zwiększanie o wartość;
  15. -= zmniejszanie o wartość;
  16. *= mnożenie przez wartość;
  17. /= dzielenie przez wartość;
  18. %= dzielenie modulo (reszta z dzielenia);
  19. ^= operacja bitowej alternatywy wykluczającej XOR;
  20. &= operator bitowej koniunkcji AND;
  21. |= operator bitowej alternatywy OR;
  22. << operator bitowego przesunięcia w lewo;
  23. >> operator bitowego przesunięcia w prawo;
  24. >>= operator bitowego przesunięcia w prawo;
  25. <<= operator bitowego przesunięcia w lewo;
  26. == operator równości;
  27. != operator nierówności;
  28. <= mniejsze lub równe;
  29. >= większe lub równe;
  30. && oraz (AND);
  31. || lub (OR);
  32. ++ inkrementacja;
  33. -- dekrementacja;
  34. , przecinek;
  35. ->*
  36. ->
  37. () operator funktora mogący przyjmować dowolną liczbę argumentów;
  38. [] operator indeksowania tablic;
  39. new operator dynamicznego przydzielenia pamięci;
  40. new[] operator dynamicznego przydzielenia pamięci;
  41. delete operator zwalniania pamięci;
  42. delete[] operator zwalniania pamięci;
  43. typ_danych() operatory rzutowania

Obsługa operatorów

Czas zakasać rękawy i nieco pobawić się w obsługę operatorów, co też i czynię w poniższym przykładowym kodzie:

#include <iostream> #include <vector> #include <math.h> using namespace std; struct POINT{ // deklaracja przykładowej struktury, potrzebnej do zademostrowania mechanizmu operatora rzutowania int x; int y; }; class point2d{ private: double x; double y; public: point2d():x(0),y(0){}; point2d(double x,double y):x(x),y(y){}; point2d(const point2d &p):x(p.x),y(p.y){}; point2d(point2d &p):x(p.x),y(p.y){}; inline double GetLength() const {return sqrt(x * x + y * y);} // operator podstawiania point2d & operator =(const point2d &p){ x = p.x; y = p.y; return *this;}; // proste podstawienie point2d & operator =(const double length){ // ustaiwa długość wektora if(x!=0 && y !=0){ // gdy jego wartość nie jest równa zero double k = length / GetLength(); // oblicz współczynnik skalowania x *= k; // skalowanie x y *= k; // skalowanie y } return *this; }; // operatory porównania wartości inline bool operator == (const point2d &p) const {return x * x + y * y == p.x * p.x + p.y * p.y;}; inline bool operator == (const double &length) const {return x * x + y * y == length * length;}; inline bool operator != (const point2d &p) const {return x * x + y * y != p.x * p.x + p.y * p.y;}; inline bool operator != (const double &length) const {return x * x + y * y != length * length;}; inline bool operator <(const point2d &p) const {return x * x + y * y < p.x * p.x + p.y * p.y;}; inline bool operator <(const double &length) const {return x * x + y * y < length * length;}; inline bool operator >(const point2d &p) const {return x * x + y * y > p.x * p.x + p.y * p.y;}; inline bool operator >(const double &length) const {return x * x + y * y > length * length;}; inline bool operator >=(const point2d &p) const {return x * x + y * y >= p.x * p.x + p.y * p.y;}; inline bool operator >=(const double &length) const {return x * x + y * y >= length * length;}; inline bool operator <=(const point2d &p) const {return x * x + y * y <= p.x * p.x + p.y * p.y;}; inline bool operator <=(const double &length) const {return x * x + y * y <= length * length;}; // Operatory matematyczne inline point2d & operator +=(const point2d &p){x += p.x; y += p.y;return *this;}; // dodawanie dwóch wektorów inline point2d & operator -=(const point2d &p){x -= p.x; y -= p.y;return *this;}; // odejmowanie dwóch wektorów inline point2d & operator *=(const double &k){x *= k; y *= k;return *this;}; // iloczyn wektora przez skalar inline point2d & operator /=(const double &k){x /= k; y /= k;return *this;}; // iloraz wektora przez skalar inline double operator *(const point2d &p){ // iloczyn skalarny dwoch wektorów return x * p.x + p.y * y; }; friend ostream & operator << (ostream & ostr, const point2d & p2d); inline double operator [](const unsigned int &i){return i % 2 ? y : x;};// zwraca wartość x, gdy i % 2 == 0; w przeciwnym razie zwraca y inline void operator ()(unsigned int i, double walue){if(i % 2) y=walue; else x = walue; }; inline void operator ()(double x, double y){ // ustawianie wartości współrzędnych this->x = x; this->y = y; } // operatory rzutowania inline operator POINT() const {POINT pt; pt.x = x; pt.y = y; return pt;}; /*point2d operator +(const point2d p){point2d p1(x + p.x, y + p.y); return p1;};*/ }; ostream & operator << (ostream & ostr, const point2d & p2d) // przeciążanie operatora << dla wypisywania tekstu { return ostr <<"X= "<<p2d.x<<" Y="<<p2d.y<<endl; } point2d operator +(const point2d &p1, const point2d &p2){ // zewnętrzny operator dodawania point2d p = p1; p += p2; return p; } point2d operator -(const point2d &p1, const point2d &p2){ // zewnętrzny operator dodawania point2d p = p1; p -= p2; return p; } // operator porównania z lewym argumentem typu double a prawym typu point2d bool operator == (const double length, const point2d &p){ return p == length; // wykorzystanie operatora zawartego w definicji klasy point2d } bool operator != (const double length, const point2d &p){ return p != length; // wykorzystanie operatora zawartego w definicji klasy point2d } bool operator < (const double length, const point2d &p){ return p > length; // wykorzystanie operatora zawartego w definicji klasy point2d } bool operator > (const double length, const point2d &p){ return p < length; // wykorzystanie operatora zawartego w definicji klasy point2d } bool operator <= (const double length, const point2d &p){ return p >= length; // wykorzystanie operatora zawartego w definicji klasy point2d } bool operator >= (const double length,const point2d &p){ return p <= length; // wykorzystanie operatora zawartego w definicji klasy point2d } int main(){ point2d p(10,0); point2d p2 = p; // wywołanie operatora podstawienia p += p2; // wywołanie wewnętrznego operatora += cout<<p; // wywołanie operatora << p = p2 + p; //wywołanie operatora zewnętrznego + cout<<p; // wywołanie operatora << if(p == p2){ // wywołanie operatora wewnętrznego klasy point2d != cout<<"p = p2"<<endl; }else{ cout<<"p != p2"<<endl; } if(p != p){ // wywołanie operatora wewnętrznego klasy point2d != cout<<"p!=p"<<endl; }else{ cout<<"p=p"<<endl; } if(10. < p2){ // wywołanie zewnętrznego operatora < cout<<"|p2| >= 10"<<endl; }else if(10. == p2){ // wywołanie zewnętrznego operatora == cout<<"|p2| = 10"<<endl; }else if(10. > p2){ // wywołanie operatora zewnętrznego > cout<<"|p2|< 10"<<endl; } p2(1u,10.); // wywołanie funktora ustawiającgo podaną współrzędną wektora p2 (typ unsigned int jako pierwszy argument i double jako drugi); cout<<p2; // wywołanie operatora << p2(100.,100.); // wywołanie funktora ustawiającego obie współrzędne (typy double jako argumenty) cout<<p2; // wywołanie operatora << cout<<"Iloczyn skalarny p i p2 wynosi: "<<p*p2<<endl; // tutaj wywołuję operator mnożenia skalarnego * p2 /= 3.14; // wywołanie operatora dzielenia przez skalar cout<<p2; // wywołanie operatora << POINT pt = POINT(p2); // wywołanie operatora typu point2d na POINT cout<<"Zrzutowane na strukture POINT wspolrzedne: X="<<pt.x<<"; Y="<<pt.y<<endl<<endl; cout<<"Wcisnij enter, aby zamknac porgram..."; cin.get(); return 0; }
Propozycje książek