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

Stronę tą wyświetlono już: 276 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:

Listing 1
  1. #include <iostream>
  2. #include <vector>
  3. #include <math.h>
  4. using namespace std;
  5. struct POINT{ // deklaracja przykładowej struktury, potrzebnej do zademostrowania mechanizmu operatora rzutowania
  6. int x;
  7. int y;
  8. };
  9. class point2d{
  10. private:
  11. double x;
  12. double y;
  13. public:
  14. point2d():x(0),y(0){};
  15. point2d(double x,double y):x(x),y(y){};
  16. point2d(const point2d &p):x(p.x),y(p.y){};
  17. point2d(point2d &p):x(p.x),y(p.y){};
  18. inline double GetLength() const {return sqrt(x * x + y * y);}
  19. // operator podstawiania
  20. point2d & operator =(const point2d &p){
  21. x = p.x;
  22. y = p.y;
  23. return *this;}; // proste podstawienie
  24. point2d & operator =(const double length){ // ustaiwa długość wektora
  25. if(x!=0 && y !=0){ // gdy jego wartość nie jest równa zero
  26. double k = length / GetLength(); // oblicz współczynnik skalowania
  27. x *= k; // skalowanie x
  28. y *= k; // skalowanie y
  29. }
  30. return *this;
  31. };
  32. // operatory porównania wartości
  33. inline bool operator == (const point2d &p) const {return x * x + y * y == p.x * p.x + p.y * p.y;};
  34. inline bool operator == (const double &length) const {return x * x + y * y == length * length;};
  35. inline bool operator != (const point2d &p) const {return x * x + y * y != p.x * p.x + p.y * p.y;};
  36. inline bool operator != (const double &length) const {return x * x + y * y != length * length;};
  37. inline bool operator <(const point2d &p) const {return x * x + y * y < p.x * p.x + p.y * p.y;};
  38. inline bool operator <(const double &length) const {return x * x + y * y < length * length;};
  39. inline bool operator >(const point2d &p) const {return x * x + y * y > p.x * p.x + p.y * p.y;};
  40. inline bool operator >(const double &length) const {return x * x + y * y > length * length;};
  41. inline bool operator >=(const point2d &p) const {return x * x + y * y >= p.x * p.x + p.y * p.y;};
  42. inline bool operator >=(const double &length) const {return x * x + y * y >= length * length;};
  43. inline bool operator <=(const point2d &p) const {return x * x + y * y <= p.x * p.x + p.y * p.y;};
  44. inline bool operator <=(const double &length) const {return x * x + y * y <= length * length;};
  45. // Operatory matematyczne
  46. inline point2d & operator +=(const point2d &p){x += p.x; y += p.y;return *this;}; // dodawanie dwóch wektorów
  47. inline point2d & operator -=(const point2d &p){x -= p.x; y -= p.y;return *this;}; // odejmowanie dwóch wektorów
  48. inline point2d & operator *=(const double &k){x *= k; y *= k;return *this;}; // iloczyn wektora przez skalar
  49. inline point2d & operator /=(const double &k){x /= k; y /= k;return *this;}; // iloraz wektora przez skalar
  50. inline double operator *(const point2d &p){ // iloczyn skalarny dwoch wektorów
  51. return x * p.x + p.y * y;
  52. };
  53. friend ostream & operator << (ostream & ostr, const point2d & p2d);
  54. inline double operator [](const unsigned int &i){return i % 2 ? y : x;};// zwraca wartość x, gdy i % 2 == 0; w przeciwnym razie zwraca y
  55. inline void operator ()(unsigned int i, double walue){if(i % 2)
  56. y=walue;
  57. else
  58. x = walue;
  59. };
  60. inline void operator ()(double x, double y){ // ustawianie wartości współrzędnych
  61. this->x = x;
  62. this->y = y;
  63. }
  64. // operatory rzutowania
  65. inline operator POINT() const {POINT pt; pt.x = x; pt.y = y; return pt;};
  66. /*point2d operator +(const point2d p){point2d p1(x + p.x, y + p.y);
  67. return p1;};*/
  68. };
  69. ostream & operator << (ostream & ostr, const point2d & p2d) // przeciążanie operatora << dla wypisywania tekstu
  70. {
  71. return ostr <<"X= "<<p2d.x<<" Y="<<p2d.y<<endl;
  72. }
  73. point2d operator +(const point2d &p1, const point2d &p2){ // zewnętrzny operator dodawania
  74. point2d p = p1;
  75. p += p2;
  76. return p;
  77. }
  78. point2d operator -(const point2d &p1, const point2d &p2){ // zewnętrzny operator dodawania
  79. point2d p = p1;
  80. p -= p2;
  81. return p;
  82. }
  83. // operator porównania z lewym argumentem typu double a prawym typu point2d
  84. bool operator == (const double length, const point2d &p){
  85. return p == length; // wykorzystanie operatora zawartego w definicji klasy point2d
  86. }
  87. bool operator != (const double length, const point2d &p){
  88. return p != length; // wykorzystanie operatora zawartego w definicji klasy point2d
  89. }
  90. bool operator < (const double length, const point2d &p){
  91. return p > length; // wykorzystanie operatora zawartego w definicji klasy point2d
  92. }
  93. bool operator > (const double length, const point2d &p){
  94. return p < length; // wykorzystanie operatora zawartego w definicji klasy point2d
  95. }
  96. bool operator <= (const double length, const point2d &p){
  97. return p >= length; // wykorzystanie operatora zawartego w definicji klasy point2d
  98. }
  99. bool operator >= (const double length,const point2d &p){
  100. return p <= length; // wykorzystanie operatora zawartego w definicji klasy point2d
  101. }
  102. int main(){
  103. point2d p(10,0);
  104. point2d p2 = p; // wywołanie operatora podstawienia
  105. p += p2; // wywołanie wewnętrznego operatora +=
  106. cout<<p; // wywołanie operatora <<
  107. p = p2 + p; //wywołanie operatora zewnętrznego +
  108. cout<<p; // wywołanie operatora <<
  109. if(p == p2){ // wywołanie operatora wewnętrznego klasy point2d !=
  110. cout<<"p = p2"<<endl;
  111. }else{
  112. cout<<"p != p2"<<endl;
  113. }
  114. if(p != p){ // wywołanie operatora wewnętrznego klasy point2d !=
  115. cout<<"p!=p"<<endl;
  116. }else{
  117. cout<<"p=p"<<endl;
  118. }
  119. if(10. < p2){ // wywołanie zewnętrznego operatora <
  120. cout<<"|p2| >= 10"<<endl;
  121. }else if(10. == p2){ // wywołanie zewnętrznego operatora ==
  122. cout<<"|p2| = 10"<<endl;
  123. }else if(10. > p2){ // wywołanie operatora zewnętrznego >
  124. cout<<"|p2|< 10"<<endl;
  125. }
  126. p2(1u,10.); // wywołanie funktora ustawiającgo podaną współrzędną wektora p2 (typ unsigned int jako pierwszy argument i double jako drugi);
  127. cout<<p2; // wywołanie operatora <<
  128. p2(100.,100.); // wywołanie funktora ustawiającego obie współrzędne (typy double jako argumenty)
  129. cout<<p2; // wywołanie operatora <<
  130. cout<<"Iloczyn skalarny p i p2 wynosi: "<<p*p2<<endl; // tutaj wywołuję operator mnożenia skalarnego *
  131. p2 /= 3.14; // wywołanie operatora dzielenia przez skalar
  132. cout<<p2; // wywołanie operatora <<
  133. POINT pt = POINT(p2); // wywołanie operatora typu point2d na POINT
  134. cout<<"Zrzutowane na strukture POINT wspolrzedne: X="<<pt.x<<"; Y="<<pt.y<<endl<<endl;
  135. cout<<"Wcisnij enter, aby zamknac porgram...";
  136. cin.get();
  137. return 0;
  138. }

Komentarze