[c++] Liczby zespolone, mnożenie.

#pragma once
#include <iostream>
using namespace std;

class CComplex
{
public:
    CComplex( double = 0, double = 0 ); //konstruktor z parametrami domyslnymi
    CComplex( const CComplex & c ); // konstruktor kopiujacy
   
public:
    CComplex & operator =( const CComplex & c ); //operator podstawienia
   
    friend istream & operator >>( istream & in, CComplex & c ); // operator wejscia
    friend ostream & operator <<( ostream & out, const CComplex & c ); // operator wyjscia
   
    friend CComplex operator +( const CComplex & c1, const CComplex & c2 );
    friend CComplex operator -( const CComplex & c1, const CComplex & c2 );
   
    friend CComplex operator *( const CComplex & c1, const CComplex & c2 );
    friend CComplex operator *( const CComplex & c, int x );
    friend CComplex operator *( int x, const CComplex & c );
   
    CComplex & operator +=( const CComplex & c );
    CComplex & operator *=( const CComplex & c );
    CComplex & operator *=( int x );
   
   
private:
    double m_re;
    double m_im;
   
public:
    double GetRe() const;
    double GetIm() const;
    void SetRe( double re );
    void SetIm( double im );
    void SetComplex( double re, double im );
    double modul() const;
   
};

inline void CComplex::SetComplex( double re, double im )
{
    SetRe( re );
    SetIm( im );
}

inline double CComplex::GetRe() const
{
    return m_re;
}
inline double CComplex::GetIm() const
{
    return m_im;
}

inline void CComplex::SetIm( double im )
{
    m_im = im;
}

inline void CComplex::SetRe( double re )
{
    m_re = re;
}

#include "StdAfx.h"
#include "Complex.h"

CComplex::CComplex( double m_re, double m_im )
{
    SetComplex( m_re, m_im );
}

CComplex::CComplex( const CComplex & c )
{
    * this = c;
}

CComplex & CComplex::operator =( const CComplex & c )
{
    m_re = c.m_re;
    m_im = c.m_im;
    return * this;
}

istream & operator >>( istream & in, CComplex & c )
{
    in >> c.m_re;
    in >> c.m_im;
    return in;
}
ostream & operator <<( ostream & out, const CComplex & c )
{
    out << '(';
    out << c.GetRe();
    out << ',';
    out << c.GetIm();
    out << ')';
    return out;
}

CComplex operator +( const CComplex & c1, const CComplex & c2 )
{
    CComplex res( c1 );
    res += c2;
    return res;
}

CComplex operator *( const CComplex & c1, const CComplex & c2 )
{
    CComplex c;
    c *= c2;
    return c;
   
    //return 0;
}

CComplex & CComplex::operator +=( const CComplex & c )
{
    m_re += c.m_re;
    m_im += c.m_im;
    return * this;
}

CComplex operator *( const CComplex & c, int x )
{
    CComplex res;
    res *= x;
    return res;
    // return 0;
}

CComplex operator *( int x, const CComplex & c )
{
    return c * x;
   
}



CComplex & CComplex::operator *=( int x )
{
    m_re *= x;
    m_im *= x;
    return * this;
}
CComplex & CComplex::operator *=( const CComplex & c )
{
    m_re = m_re * c.m_re - m_im * c.m_im;
    m_im = m_re * c.m_im + m_im * c.m_re;
    return * this;
   
   
}

/*double modul() const
{
return 0;
}
*/