C++ Szablon klasy dla liczb zespolonych

template < typename Type >
class Complex
{
    Type m_real;
    Type m_image;
public:
    Complex( Type re = 0, Type im = 0 )
        : m_real( re )
         , m_image( im )
    { }
    ~Complex() { }
   
    Type getReal() const { return m_real; }
    Type getImage() const { return m_image; }
   
    Complex operator +( const Complex & z ) // wersja dla (zesp + zesp2)
    {
        Complex temp = * this;
        //return Complex(this->m_real + z.m_real, this->m_image + z.m_image);
        // lub
        return temp += z; // lepiej ta opcja, korzysta z operator+=, nie ma powielania kodu
    }
   
    Complex operator +( Type num ) // wersja dla (zesp + liczba)
    {
        //... twój kod
    }
   
    friend Complex < Type > operator +( Type num, const Complex < Type >& z ) // wersja dla (liczba + zesp)
    {
        //... twój kod
    }
   
    Complex operator +=( const Complex & z ) // wer. dla (zesp += zesp2)
    {
        this->m_real += z.m_real;
        this->m_image += z.m_image;
        return * this;
    }
   
    Complex operator +=( Type num ) // wer. dla (zesp += liczba)
    {
        // ... twój kod
    }
   
    // resztę implementacji pozostawiam
   
    template < typename Type >
    friend std::ostream & operator <<( std::ostream & os, const Complex < Type >& z )
    {
        return os << "[" << z.m_real << " + " << z.m_image << "]";
    }
};

int main()
{
    Complex < int > a( 1, 2 );
    Complex < int > b( 2, 4 );
    std::cout <<( a + b ) << std::endl;
    std::cout << "[" << a.getReal() << " + " << a.getImage() << "]" << std::endl;
}