C++封装复数类，实现复数运算

在复数类Complex中定义了两个私有的成员变量 real 和 img 分别表示复数的实部和虚部，然后定义了几个共有的成员函数：两个构造方法，一个为不带参的默认构造函数，另一个为 带两个参数的构造函数，通过该构造函数实现对私有成员变量real和img的初始化，然后是一个没有返回值对的disp（）函数用来显示输出复数的值，接下来就是对四则运算的重载函数和一个赋值重载运算符的重载，用来计算该复数的共轭复数，以及一个>运算符的重载用来判断复数的大小。最后是一个普通的成员函数，用来进行复数的取模运算。

样例输出为：

1-2* i
2+3* i
两复数相加为：3+1* i
两复数相减为：-1-5* i
两复数相乘为：8-1* i
两复数相除为：-0.307692-0.538462*i
该复数的模为：2.23607
第一个复数小于第二个复数
Press any key to continue

下面是我的代码：

#include "math.h"
#include<iostream>
using namespace std;

class Complex{
private:
	double real;
	double img;
public:
	Complex();
	Complex(double r,double i);
	void disp();
	Complex operator + (const Complex &c);
    Complex operator - (const Complex &c);
    Complex operator * (const Complex &c);
    Complex operator / (const Complex &c);
	//使用赋值运算符的重载来计算共轭复数
	Complex& operator=(const Complex &c);
	//比较复数的大小
	bool operator>(const Complex &c);
	//取模运算
	double getMol();
};

Complex::Complex(){

}
Complex::Complex(double r,double i):real(r),img(i)//通过使用初始化列表来初始化参数
{

}
Complex& Complex::operator=(const Complex &c){
	this->real=c.real;
	this->img=c.img*(-1);//共轭复数
	return *this;
}
void Complex::disp(){
	if(img>0){
		cout<<real<<'+'<<img<<"*i"<<endl;
	}else if(img==0){
		cout<<real<<endl;
	}else if(img<0){
		cout<<real<<img<<"*i"<<endl;
	}
}
double Complex::getMol(){//取模运算
	return sqrt(real*real+img*img);
}
Complex Complex::operator+(const Complex &c){
	Complex a;
	a.real=real+c.real;
	a.img=img+c.img;
	cout<<"两复数相加为：";
	return a;
}
Complex Complex::operator -(const Complex &c){
	Complex a;
	a.real=real-c.real;
	a.img=img-c.img;
	cout<<"两复数相减为：";
	return a;
}
Complex Complex::operator *(const Complex &c){
	Complex a;
	a.real=real*c.real-img*c.img;
	a.img=real*c.img+img*c.real;
	cout<<"两复数相乘为：";
	return 	a;
}
Complex Complex::operator /(const Complex &c){

	Complex tmp;
	Complex cc;
	cc=c;
	Complex parent;
	parent.real=c.real*cc.real-cc.img*c.img;//相互共轭的两个复数的乘积运算
	
	tmp.real=(real*cc.real-img*cc.img)/parent.real;
	tmp.img=(real*cc.img+img*cc.real)/parent.real;

	cout<<"两复数相除为：";
	return tmp;
}
bool Complex::operator>(const Complex &c){
	return real>c.real && img>c.img;
}
int main(int argc, char* argv[])
{
	Complex c1(1,-2);
	Complex c2(2,3);
	c1.disp();
	c2.disp();

	Complex cAdd=c1.operator +(c2);
	cAdd.disp();

	Complex cSub=c1.operator -(c2);
	cSub.disp();

	Complex cMul=c1.operator *(c2);
	cMul.disp();

	Complex cChu=c1.operator /(c2);
	cChu.disp();

	double mol=c1.getMol();
	cout<<"该复数的模为："<<mol<<endl;

	bool isBig=c1.operator >(c2);
	if(isBig==true){
		cout<<"第一个复数大于第二个复数"<<endl;
	}else{
		cout<<"第一个复数小于第二个复数"<<endl;
	}
	return 0;
}

在这里我们需要注意的是复数的除法运算，复数的除法：

通过计算除数与除数的共轭复数的乘积，将分母公约化。在代码里

Complex cc;
cc=c;

这里就调用了赋值运算符的的重载，在该重载函数中我将c的虚部的相反数赋值给了cc，cc就是c的共轭复数。
后面在主函数中：

Complex c1(1,-2);
Complex c2(2,3);

在这里，定义Complex的两个对象的同时，系统自动调用了我定义的带两个参数的构造函数，在定义的同时进行了对 对象的初始化。