通过运算符重载实现复数运算

#include<iostream>
using namespace std;
class Complex
{
public:
// 带缺省值的构造函数
Complex(double real = 0, double image = 0)
{
cout << "带缺省值的构造函数" << endl;
_real = real;
_image = image;
}
// 析构函数
~Complex()
{
cout << "析构函数" << endl;
}
// 拷贝构造函数
Complex(const Complex& d)
{
cout << "拷贝构造函数" << endl;
_real = d._real;
_image = d._image;
}
// 赋值运算符重载
Complex& operator= (const Complex& d)
{
cout << "赋值运算符重载" << endl;
if (&d != this)
{
_real = d._real;
_image = d._image;
}

return *this;
}
void Display()
{
cout << "real = " << _real << "  " << "image = " << _image << endl;
}

public:
Complex& operator++()//前置++
{
_real++;
return *this;
}
Complex operator++(int)//后置++ int为标示符区分前置++和后置++
{
Complex tmp(*this);
_real++;
return tmp;
}

Complex& operator--()//前置--
{
_real--;
return *this;
}
Complex operator--(int)//后置--
{
Complex tmp(*this);
_real--;
return tmp;
}

Complex operator+(const Complex& c)
{
Complex tmp;
tmp._real = _real + c._real;
tmp._image = _image + c._image;
return tmp;
}
Complex operator-(const Complex& c)
{
Complex tmp;
tmp._real = this->_real - c._real;
tmp._image = this->_image - c._image;
return tmp;
}

Complex& operator-=(const Complex& c)
{
_real -= c._real;
_image -= c._image;
return *this;
}
Complex& operator+=(const Complex& c)
{
_real += c._real;
_image += c._image;
return *this;
}

Complex operator*(const Complex& c)
{
Complex tmp;
tmp._real = (_real * c._real) - (_image * c._image);
tmp._image = (_real * c._image) + (_image * c._real);
return tmp;
}
Complex operator/(const Complex& c)
{
Complex tmp;
double t = (c._real * c._real) + (c._image * c._image);
tmp._real = (_real * c._real - _image * c._image) / t;
tmp._image = (_real * c._image + _image * c._real) / t;
return tmp;
}

private:
double _real;       // 实部
double _image;      // 虚部
};
void TestMultiply()
{
Complex c1(3.3, 1.1), c2(1.1, 2.2);
Complex c3;
c3 = c1 * c2; //(1.21,8.47)
c3.Display();
}
void TestDivide()
{
Complex c1(3.3, 1.1), c2(1.1, 2.2);
Complex c3;
c3 = c1 / c2; //(0.2,1.4)
c3.Display();
}
void TestAdd_Reduce()
{
Complex c1(4.3, 2.1), c2(1.5, 6.5), c3;
c3 = c2 + c1;
c3.Display();//(5.8,8.6)
c3 = c2 - c1;//(2.2,1.1)
c3.Display();
}

int main()
{
Complex c1(2.2, 1.1);
Complex c2(c1);//代入法拷贝构造
c1.Display();
c2.Display();
Complex c3 = c1;//赋值法拷贝构造
c3.Display();
Complex c4(3.3, 1.1);
c1 = c4;//赋值运算符重载
c1.Display();

++c4;//(4.3,1.1)
c4.Display();
--c4;//(3.3,1.1)
c4.Display();
c3 = c4++;
c3.Display();//(3.3,1.1)
c4.Display();//(4.3,1.1)
c4 -= c1;// (1,0)
c4.Display();
c4 += c1;//(4.3,1.1)
c4.Display();

TestAdd_Reduce();
TestMultiply();
TestDivide();
getchar();
return 0;
}