Operator Przeciążenie w struktury

Question

Załóżmy zdefiniować tę strukturę:

struct Point { 
    double x, y; 
}; 

Jak mogę przeciążać operatora + tak, oświadczył

Point a, b, c; 
double k; 

ekspresję

c = a + b; 

plony

c.x = a.x + b.x; 
c.y = a.y + b.y; 

i wyrażenie

c = a + k; 

daje

c.x = a.x + k; 
c.y = a.y + k; // ? 

będzie przemienne hold nieruchomość za tym ostatnim przypadku? To znaczy, czy należy oddzielnie traktować c = a + k; i c = k + a;?

Answer 1

Wystarczy zrobić:

Point operator+(Point const& lhs, Point const& rhs); 
Point operator+(Point const& lhs, double rhs); 
Point operator+(double lhs, Point const& rhs); 

W odniesieniu do ostatniego pytania, kompilator czyni żadnych założenia dotyczące tego, co robi operator. (Należy pamiętać, że operatorjest komutatywny.) Tak więc musisz zapewnić oba przeciążenia.

Alternatywnie, można zapewnić niejawnego konwersję double do Point (poprzez konwertującego konstruktora Point). W takim przypadku, pierwsze przeciążenie powyżej obsłuży wszystkie trzy przypadki .

Answer 2

W C++ istnieje tylko jedna różnica między strukturą a klasą: w strukturze domyślna widoczność jest jawna, podczas gdy w klasie jest prywatna.

Poza tym można zrobić wszystko, co można zrobić w klasie w strukturze i będzie wyglądać dokładnie tak samo.

Napisz przeciążenie operatora w strukturze, tak jak w klasie.

Answer 3

Oto, jak bym to zrobił.

struct Point { 
    double x, y; 
    struct Point& operator+=(const Point& rhs) { x += rhs.x; y += rhs.y; return *this; } 
    struct Point& operator+=(const double& k) { x += k; y += k; return *this; } 
}; 

Point operator+(Point lhs, const Point& rhs) { return lhs += rhs; } 
Point operator+(Point lhs, const double k) { return lhs += k; } 
Point operator+(const double k, Point rhs) { return rhs += k; } 

Answer 4

Będzie to również działa:

struct Point{ 
    double x,y; 
    Point& operator+(const Point& rhs){ 
      x += rhs.x; 
      y += rhs.y; 
      return *this; 
    } 
}