Niepoprawny kod, gdzie mam błąd?

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 :-)

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();
}

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;

#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.