Stronę tą wyświetlono już: 6357 razy
Lista operatorów możliwych do przeciążenia
Poniżej zamieszczam listę operatorów, które można przeciążać:
- + operator ten może przyjmować jeden lub dwa argumenty;
- - operator ten może przyjmować jeden lub dwa argumenty;
- * mnożenie;
- / dzielenie;
- % dzielenie modulo;
- ^ operator bitowej alternatywy wykluczającej XOR;
- & dwuarguumentowy operator bitowej koniunkcji AND, lub jednoargumentowy operator uzyskania adresu;
- | operator bitowej alternatywy OR;
- ~ operator negacji bitowej jednoargumentowy;
- ! operator negacji wartości NOT;
- = operator podstawienia;
- < mniejsze niż;
- > większe niż;
- += zwiększanie o wartość;
- -= zmniejszanie o wartość;
- *= mnożenie przez wartość;
- /= dzielenie przez wartość;
- %= dzielenie modulo (reszta z dzielenia);
- ^= operacja bitowej alternatywy wykluczającej XOR;
- &= operator bitowej koniunkcji AND;
- |= operator bitowej alternatywy OR;
- << operator bitowego przesunięcia w lewo;
- >> operator bitowego przesunięcia w prawo;
- >>= operator bitowego przesunięcia w prawo;
- <<= operator bitowego przesunięcia w lewo;
- == operator równości;
- != operator nierówności;
- <= mniejsze lub równe;
- >= większe lub równe;
- && oraz (AND);
- || lub (OR);
- ++ inkrementacja;
- -- dekrementacja;
- , przecinek;
- ->*
- ->
- () operator funktora mogący przyjmować dowolną liczbę argumentów;
- [] operator indeksowania tablic;
- new operator dynamicznego przydzielenia pamięci;
- new[] operator dynamicznego przydzielenia pamięci;
- delete operator zwalniania pamięci;
- delete[] operator zwalniania pamięci;
- 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;
}