C++运算符重载的示例代码

免得时间长又忘记了，这里贴一下。

#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

/*
Title: C++运算符重载的示例代码
Description: 
       unary operator，binary operator，index operator, stream operator
Environment: VS2017 Update5
Date: 2018-1-23
Author: kagula
Remark:
[1]Note right value reference type, when function return.
*/

struct Point {
	int x;
	int y;

	Point():x(0),y(0)	{	}

	Point(int inX, int inY) :x(inX), y(inY) {	}

	//演示比较运算符的重载
	//比较哪个距离原点比较远
	bool operator < (const Point &right)
	{
		int thisDistanceFromOriginal = sqrt(this->x * this->x + this->y * this->y);
		int rightDistanceFromOriginal = sqrt(right.x * right.x + right.y * right.y);

		if (thisDistanceFromOriginal < rightDistanceFromOriginal)
		{
			return true;
		}
		return false;
	}//>

	//演示单目算术运算符的重载
	int operator[](unsigned int i)  //a[任意整数]，例：a[5312]
	{
		if (i==0)
		{
			return this->x;
		}

		if (i == 1)
		{
			return this->y;
		}
		return 0;
	}

	//仅用于demo，operator=重定义没什么实际意义。
	//因为默认就是对Data segment进行bit copy.
	Point & operator=(const Point &src)
	{
		this->x = src.x;
		this->y = src.y;
		return *this;
	}

	Point & operator ++ ()// ++前缀
	{
		this->x++, this->y++;
		return *this;
	}//++

	const Point operator++(int) // ++后缀
	{
		this->x++, this->y++;

		return *this;
	}

	Point & operator+=(const Point &src) // += 操作符
	{
		this->x += src.x;
		this->y += src.y;

		return *this;
	}

	//演示双目算术运算符的重载
	Point & operator + (const Point &right)
	{
		//补充：
		//情况：
		//分配Point ret后，返回给caller后由于callee分配的ret对象已经被释放了，
		//导致调用者拿到的是无效数据。
		//这种情况的解决办法是，把返回类型从“Point&”改为“Point”。
		this->x += right.x;
		this->y += right.y;
		
		return *this;
	}//+

	//演示输出流运算符的重载
	//左边是自己，右边是输出流，返回是输出流。
	//要求左边是自己，所以这里的定义很少用到。
	std::ostream &operator<< (std::ostream &stream)
	{
		stream << "P(" << this->x << "," << this->y << ")[" << sqrt(this->x * this->x + this->y * this->y) << "]";
		return stream;
	}//>

	//演示input stream运算符的重载
	//要求左边是自己，所以这里的定义很少用到。
	Point& operator >> (std::istream &stream)
	{
		stream >> this->x;
		stream >> this->y;
		return *this;
	}//>
};

//演示输入流运算符的重载
//为了支持左边输入流类型只能在struct外面再定义一个input stream override function.
//左边是输入流，右边是我的对象，返回的是我的对象。
std::istream &operator>> (std::istream &stream, Point &pt)
{
	stream >> pt.x >> pt.y;
	return stream;
}

//演示输出流运算符的重载
//为了支持左边输出流类型只能在struct外面再定义一个output stream override function.
//左边是输出流，右边是我的对象，返回是输出流。
std::ostream &operator<< (std::ostream &stream, const Point &pt)
{
	stream << "P(" << pt.x << "," << pt.y << ")[" << sqrt(pt.x * pt.x + pt.y * pt.y) << "]";
	return stream;
}

//为了使用std::algorithm只能在struct外面再定义一个compare override function.
bool PointCompareLess(Point& s1, const Point& s2)
{
	return s1 < s2;
}

inline void print2console(std::vector<Point> &vecPoint)
{
	for (size_t i = 0; i < vecPoint.size(); i++)
	{
		std::cout << vecPoint[i];
		std::cout << ", ";
	}

	std::cout << std::endl << "=================================" << std::endl;
}

void demoInputStreamOvverride(std::vector<Point> &vecPoint)
{
	Point pt;
	std::cin >> pt;
	vecPoint.push_back(pt);

	//enter key
	std::cin.get();
}

int main(int argc, char *argv[])
{
	std::vector<Point> vecPoint;

	//准备测试用的数据
	Point vp1(1, 2);
	Point vp2(3, 4);
	Point vp3(5, 6);
	Point vp4(7, 8);
	Point vp5(9, 10);
	Point vp6(2, 2);

	vecPoint.push_back(vp1);
	vecPoint.push_back(vp2);
	vecPoint.push_back(vp3);
	vecPoint.push_back(vp4);
	vecPoint.push_back(vp5);
	vecPoint.push_back(vp6);

	//演示输入流重载
	//demoInputStreamOvverride(vecPoint);

	//先把数据在容器中的位置弄乱
	print2console(vecPoint);
	std::random_shuffle(vecPoint.begin(), vecPoint.end());
	print2console(vecPoint);

	//数据按顺序在container中重新排列
	//然后再测试operator > 运算符的重载效果
	//从小到大排列
	std::sort(vecPoint.begin(), vecPoint.end(), PointCompareLess);
	print2console(vecPoint);

	std::cout << "测试++前缀" << endl;
	++vecPoint[0];
	print2console(vecPoint);

	std::cout << "测试++后缀" << endl;
	vecPoint[0]++;
	print2console(vecPoint);

	std::cout << "测试+" << endl;
	vecPoint[0] = vecPoint[1] + vecPoint[2];
	print2console(vecPoint);

	std::cout << "测试+=" << endl;
	vecPoint[0] += vecPoint[1];
	print2console(vecPoint);

	std::cout << "测试[] operator" << endl;
	std::cout << vecPoint[0][0] << std::endl;
	std::cout << vecPoint[0][1] << std::endl;
	std::cin.get();

	return 0;
}