C++之操作符重载及实现简单的复数类Complex

操作符重载：

重载操作符是具有特殊函数名的函数，关键字operator后面接需要定义的操作符符号。

操作符重载也是一个函数，具有返回值和形参表。它的形参数目与操作符的操作数目相同。

函数调用操作符可以接受任意数目的操作数。

使用运算符重载可以提高代码的可读性。

返回类型 operate 操作符(参数列表)；

不可重载的操作符

注意：
1、不能通过连接其他符号来创建新的操作符：比如operator@；void operator @(){}
2、重载操作符必须有一个类类型或者枚举类型的操作数
int operator +(const int _inum1 , const int _inum2 )
// 报错
{
return ( _inum1 + _inum2);
} t
ypedef enum test {one ,two ,three };
int operator+(const int _inum1 , const test _test )
{
return _inum1;
}
3、用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
5、不再具备短求职特性重载操作符不能保证操作符的求值顺序,在重载&&和||中，对每个操作数都要进行求值，而且对操作数的求职顺序不能做规定，因此：重载&&、||和逗号操作符不是好的做法。
6、作为类成员的重载函数，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参。
ctest operator+(const ctest test1, const ctest
test2)const // 报错
{
return test1;
} c
test operator+(const ctest test1)const
{
return test1;
}
7、一般将算术操作符定义为非成员函数，将赋值运算符定义成员函数
8、操作符定义为非类的成员函数时，一般将其定义为类的友元
9、== 和 != 操作符一般要成对重载
10、下标操作符[]：一个非const成员并返回引用，一个是const成员并返回引用
11、解引用操作符*和->操作符，不显示任何参数
13、自增自减操作符前置式++/--必须返回被增量或者减量的引用后缀式操作符必须返回旧值，并且应该是值返回而不是引用返回
14、输入操作符>>和输出操作符<<必须定义为类的友元函数
【建议】
使用重载操作符，可以令程序更自然、更直观，而滥用操作符重载会使得类难以理解，在实践中很少发生明显的操作符重载滥用。但有些程序员会定义operator+来执行减法操作，当一个重载操作符不明确时，给操作符取一个名字更好，对于很少用的操作，使用命名函数通常比用操作符好，如果不是普通操作，没有必要为简洁而用操作符。

 

实现一个复数类的以下接口：

//运算符重载
complex& operator=(const complex& d);//赋值
bool operator ==(const complex& d);//判断相等

bool operator !=(const complex& d);//判断相等

complex operator+(const complex& d);//复数相加
complex& operator+=(const complex& d); //复数对象+=d
complex operator-(const complex& d); //两个复数相减
complex& operator-=(const complex& d); //复数对象-=d
complex operator++(); //前置++
complex operator++(int); //后置++ 且不用添加参数 特殊形式
complex operator--(); //前置--
complex operator--(int); //后置--
void display(); //显示复数的实部和虚部

具体实现代码：

“complex.h”

 

#include;
using namespace std;

class complex
{
public:
	complex(int real=0, int image=0)
		:_real(real)
		, _image(image)
	{}

	~complex()
	{}

	complex(complex& com)
		:_real(com._real)
		,_image(com._image)
	{}

	//运算符重载
	complex& operator=(const complex& d)//赋值
	{
		_real = d._real;
		_image = d._image;
		return *this;
	}
	bool operator ==(const complex& d)//判断相等
	{
		return (_real == d._real) && (_image == d._image);
	}
	
	bool operator ==(const complex& d)//判断不相等
	{
		return (_real ！= d._real) || (_image ！= d._image);
	}
	
	complex operator+(const complex& d)//复数相加
	{
		complex temp(0, 0);
		temp._real = _real + d._real;
		temp._image = _image + d._image;
		return temp;
	}
	//complex& operator+(const complex& d)//复数相加
	//{
	//	_real=_real+d._real;
	//	_image = _image + d._image;
	//	return *this;
	//}
	complex& operator+=(const complex& d)  //复数对象+=d
	{
		_real += d._real;
		_image += d._image;
		return *this;
	}
	complex operator-(const complex& d)  //两个复数相减  
	{
		complex temp(0, 0);
		temp._real = _real - d._real;
		temp._image = _image - d._image;
		return temp;
	}
	complex& operator-=(const complex& d)  //复数对象-=d
	{
		_real -= d._real;
		_image -= d._image;
		return *this;
	}
	complex operator++()  //前置++
	{
		_real++;
		_image++;
		return *this;
	}
	complex operator++(int)  //后置++  且不用添加参数  特殊形式
	{
		complex temp = *this;
		_real++;
		_image++;
		return temp;
	}
	complex operator--() //前置--
	{
		_real--;
		_image--;
		return *this;
	}
	complex operator--(int)  //后置--
	{
		complex temp = *this;
		_real--;
		_image--;
		return temp;
	}
	void display()  //显示复数的实部和虚部
	{
		cout << "real:" << _real << endl;
		cout << "image:" << _image << endl;
	}
private:
	int _real;
	int _image;
};

"complex.cpp"

 

 

#include"complex.h"

int main()
{
	complex d1(5, 10);
	complex d2(7, 10);
	complex d4;

	cout << "d1(5,10)  "<<"d2(7,10)  "<<"d4(0,0)"<