C++之“运算符重载”

C++可以重载的运算符有：

1.前置++和后置++

2.前置--与后置--

3.+，-，*，/，%运算符

4.>,<,<=,>=,==,!=运算符

5.<<,>>（流提取与流插入）运算符

（特别注意：要对类的对象使用运算符，不能重载的运算符：=，& ，逗号运算符）

#include<iostream>
using namespace std;
class Operate
{
	
	friend ostream&  operator<<(ostream &out, const Operate oper1);//<<运算符
	friend istream&  operator>>(istream &input, const Operate &oper2);	//>>运算符

public:
	
	Operate(int=1 ,int=1);//构造函数

	Operate & operator-();//负号运算符
	Operate & operator++();//前面++
	Operate operator++(int);	//后置++
								
	Operate  operator+(const Operate & oper);//+号运算符
	Operate operator-(const Operate &oper);//相减运算法
	Operate operator*(const Operate &oper);//相乘运算法
	Operate operator/(const Operate &oper);//相除运算法
	Operate operator%(const Operate &oper);//相除运算法

	bool operator>(const Operate & oper);//>运算符
	bool operator<(const Operate & oper);//<运算符
	bool operator>=(const Operate & oper);//>=运算符
	bool operator<=(const Operate & oper);//<=运算符
	bool operator==(const Operate & oper);//==运算符
	bool operator!=(const Operate & oper);//!=运算符



	int  getX();//获取X
	int  getY();//获取Y




private:
	int m_iX;
	int m_iY;

};

Operate::Operate(int x, int y)
{
	m_iX = x;
	m_iY = y;
}

//负号运算符
Operate& Operate::operator-()
{
	m_iX = -m_iX;
	m_iY = -m_iY;
	return *this;
}

//前面++
Operate& Operate::operator++()
{
	m_iX++;
	m_iY++;
	return *this;
}
//后置++
Operate Operate::operator++(int)
{
	Operate old(*this);
	m_iX++;
	m_iY++;
	return old;
}

//+号运算符
Operate Operate::operator+(const Operate &oper)
{
	Operate temp;
	temp.m_iX = this->m_iX + oper.m_iX;
	temp.m_iY = this->m_iY + oper.m_iY;
	return temp;

}
//减运算符
Operate Operate::operator-(const Operate &oper)
{
	Operate temp;
	temp.m_iX = this->m_iX - oper.m_iX;
	temp.m_iY = this->m_iY - oper.m_iY;
	return temp;

}
//乘法运算符
Operate Operate::operator*(const Operate &oper)
{
	Operate temp;
	temp.m_iX = this->m_iX *oper.m_iX;
	temp.m_iY = this->m_iY * oper.m_iY;
	return temp;

}

//除运算符
Operate Operate::operator/(const Operate &oper)
{
	Operate temp;
	temp.m_iX = this->m_iX / oper.m_iX;
	temp.m_iY = this->m_iY / oper.m_iY;
	return temp;

}
//取模运算符
Operate Operate:: operator%(const Operate &oper)
{
	Operate temp;
	temp.m_iX = this->m_iX %oper.m_iX;
	temp.m_iY = this->m_iY % oper.m_iY;
	return temp;
}

//>运算符
bool Operate:: operator>(const Operate & oper)
{
	if (this->m_iX > oper.m_iX&&this->m_iY > oper.m_iY)
		return true;
	else
		return false;
}
//<运算符
bool Operate:: operator<(const Operate & oper)
{
	if (this->m_iX <oper.m_iX&&this->m_iY <oper.m_iY)
		return true;
	else
		return false;
}
//<=运算符
bool Operate:: operator<=(const Operate & oper)
{
	if (this->m_iX <=oper.m_iX&&this->m_iY <=oper.m_iY)
		return true;
	else
		return false;
}
//>=运算符
bool Operate:: operator>=(const Operate & oper)
{
	if (this->m_iX >=oper.m_iX&&this->m_iY >=oper.m_iY)
		return true;
	else
		return false;
}
//==运算符
bool Operate:: operator==(const Operate & oper)
{
	if (this->m_iX ==oper.m_iX&&this->m_iY ==oper.m_iY)
		return true;
	else
		return false;
}

//!=运算符
bool Operate:: operator!=(const Operate & oper)
{
	if (this->m_iX !=oper.m_iX&&this->m_iY !=oper.m_iY)
		return true;
	else
		return false;
}




//<<运算符的友元函数
ostream & operator<<(ostream &out, const Operate oper1)
{
	out << oper1.m_iX << "," << oper1.m_iY << endl;
	return out;
}

//>>运算符的友元函数
istream &  operator>>(istream &input,  const Operate  &oper2)
{
	input >> oper2.m_iX;
	input>> oper2.m_iY;
	return input;
}
int  Operate::getX()
{
	return m_iX;
}

int Operate::getY()
{
	return m_iY;
}

int main()
{
//main函数测试 

}

学会巧妙的使用运算符，在写很多程序中尤为重要。

运算符重载有助于C++的可扩展性，它是C++最吸引人的特征之一。当运算符重载比完成相同工作的函数调用程序更清晰的时候，请选择运算符重载！