Przeciazenie opratora +

  Complex operator+ (const Complex& co) const
{
     Complex n;
     n.Real = this->Real + co.Real;
     n.Imag = this->Imag + co.Imag;
     return n;
 };

Cześć wytłumaczy mi ktoś w jaki sposób działa takie proste dodawanie.
Mając takie dwa obiekty ** Complex a(0.0,15),b(0,13);**

c = a + b;

Co tu właściwie do tłumaczenia? Mając

Complex a{0,1}, b{1,0};

Następujące będą równoważne:

Complex c = a+b;
Complex c = a.operator+(b);

Operator to normalna funkcja. Swoją drogą, + powinien być realizowany jako zewnętrzna funkcja i w oparciu o operator +=: https://dsp.krzaq.cc/post/304/jak-przeladowywac-operatory-w-mojej-klasie/

Czyli jak rozumiem wskaźnik this odnosi się do liczby z lewej strony plusa natomiast argument to liczba z prawej strony?

Jeszcze jedno pytanie dlaczego w takim wypadku uzywa sie referencji skoro bez niej program działa dokładnie tak samo?

Referencje pozwalają uniknąć zbędnego kopiowania.

"Operator to normalna funkcja. Swoją drogą, + powinien być realizowany jako zewnętrzna funkcja i w oparciu o operator +=" Tylko trzeba pamiętać, że wtedy po wykonaniu:
a = b + c
zmieni się b.

lion137 napisał(a):

"Operator to normalna funkcja. Swoją drogą, + powinien być realizowany jako zewnętrzna funkcja i w oparciu o operator +=" Tylko trzeba pamiętać, że wtedy po wykonaniu:
a = b + c
zmieni się b.

Absolutnie nie.

T operator+(T b, T const& c) {
    return b += c;
}

lub mniej zwięźle:

T operator+(T const& b, T const& c) {
    T a{b};
    a += c;
    return a;
}

Jeden operator realizowany jest w oparciu o drugi, aby uprościć implementację i zachować DRY, a nie powodować jakąś dziwną semantykę.

   Complex operator/ (const Complex& co) const
  {
	    Complex n;
	    double mianownik,new_imag,new_real;
	    mianownik = (co.Real*co.Real)+(co.Imag*(-co.Imag))*-1;
	    new_imag =(this->Real*(-co.Imag))+(this->Imag*co.Real);
	    new_real = (this->Real* co.Real)-(this->Imag*(-co.Imag)); 	
	    n.Real = new_real/mianownik;
	    n.Imag = new_imag/mianownik;
	    return n;
 };
  Complex & operator /= (Complex co)
 {
    double mianownik,Real,Imag;
    mianownik = (co.Real*co.Real)+(co.Imag*(-co.Imag))*-1;
    Real = (this->Real* co.Real)-(this->Imag*(-co.Imag))/mianownik;
    Imag = (this->Real*(-co.Imag))+(this->Imag*co.Real)/mianownik;
    this->Real=Real;
    this->Imag=Imag;

    return *this;

 }

Podpowie mi ktoś dlaczego program po wywołaniu a/=b przechodzi do operatora / zamiast do /=?

kq napisał(a):

lion137 napisał(a):

"Operator to normalna funkcja. Swoją drogą, + powinien być realizowany jako zewnętrzna funkcja i w oparciu o operator +=" Tylko trzeba pamiętać, że wtedy po wykonaniu:
a = b + c
zmieni się b.

Absolutnie nie.

T operator+(T b, T const& c) {
    return b += c;
}

lub mniej zwięźle:

T operator+(T const& b, T const& c) {
    T a{b};
    a += c;
    return a;
}

Jeden operator realizowany jest w oparciu o drugi, aby uprościć implementację i zachować DRY, a nie powodować jakąś dziwną semantykę.

Nie było tematu

Mam jeszcze jedno pytanie.
W jaki sposob wykonuje sie takie odejmowanie;
b = 2 - a; gdzie a i b są obiektami klasy.
Czy dwójka staje się też obiektem klasy?

Asd napisał(a):

b = 2 - a; gdzie a i b są obiektami klasy.
Czy dwójka staje się też obiektem klasy?

Taki operator definiuje się poza klasą.

Complex operator +(int a, const Complex &b);

W razie potrzeby można dodać w klasie jako frienda, żeby mieć dostęp do pól prywatnych.