Niepoprawny kod, gdzie mam błąd?

0

Cześć!

#include <iostream>
#include <cmath>
class Complex {
    public:
        Complex(int re = 0, int im = 0) : _re(re), _im(im) {
        }
        Complex(Complex& obj) {
            _re = obj._re;
            _im = obj._im;
        }
        double mod() {
            return sqrt(pow(_im, 2) + pow(_re, 2));
        }
        void show() {
            std::cout<< _re <<"+" <<_im <<"i\n";
        }
        Complex* operator+(Complex lft) {
            return (new Complex(_re + lft._re, _im + lft._im));
        }
    private:
        int _re;
        int _im;
};
int main() {
    Complex c1(1, 1);
    Complex c2(-3, 2);
    Complex* c3 = c1 + c2;
    c3->show();
}

Jak zwróconą referencję przypisać do nowego obiektu?
Czy muszę koniecznie definiować operator przypisania dla obiektów mojej klasy? Da sie to jakoś obejść?

Pozdrawiam i dzięki za pomoc :-)

0

Oczywiście powyższy kod operuje na wskaźnikach. Chciałem sobie przypomnieć referencje ale nie mogę wymyślić jak zrealizować to samo za ich pomocą. Oczywiście zmieniłem typ zwracany przez operator i deklarację c3 na deklarację referencji ale nadal nie gra:

#include <iostream>
#include <cmath>
class Complex {
    public:
        Complex(int re = 0, int im = 0) : _re(re), _im(im) {
        }
        Complex(Complex& obj) {
            _re = obj._re;
            _im = obj._im;
        }
        double mod() {
            return sqrt(pow(_im, 2) + pow(_re, 2));
        }
        void show() {
            std::cout<< _re <<"+" <<_im <<"i\n";
        }
        Complex& operator+(Complex lft) {
            return &((new Complex(_re + lft._re, _im + lft._im))*);
        }
    private:
        int _re;
        int _im;
};
int main() {
    Complex c1(1, 1);
    Complex c2(-3, 2);
    Complex& c3 = c1 + c2;
    c3.show();
}
0

Po pierwsze. Jak robisz:

return (new Complex(_re + lft._re, _im + lft._im));

to przy zapisie:

Complex c1, c2, c3, c4, c5;
//Jakieś operacje zmieniające powyższe wartości
Complex* cS = c1 + c2 + c3 + c4 + c5;

kompilator zrobi:

Complex* cS =
   ( c1 +       //new
   ( c2 +       //new
   ( c3 +       //new
   (c4 + c5) ) ) ) //new;
0
#include <iostream>
#include <cmath>

class Complex
  {
   public:
   Complex(double re=0,double im=0):_re(re),_im(im) {}
   //Complex(Complex& obj) // zbędny
   double mod()const { return sqrt(_im*_im+_re*_re); } // pow się liczy przez log i exp
   std::ostream &show(std::ostream &s)const { return s<<_re<<"+" <<_im<<"i"; }
   Complex operator+(const Complex &c)const  { return Complex(_re+c._re,_im+c._im); }
   private:
   double _re,_im;
  };
inline std::ostream &operator<<(std::ostream &s,const Complex &c) { return c.show(s); }

int main()
  {
   Complex c1(1,1),c2(-3,2);
   Complex c3=c1+c2;
   std::cout<<c1<<" + "<<c2<<" = "<<c3<<std::endl;
   return 0;
  }

Pisano na sucho mogą być błędy.

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0