对于一些编译器无法计算的运算，我们可以通过自己构造运算符来进行运算，通过operator+来实现

（1）可以通过全局函数来实现

using namespace std;
class person{
	public:
		int M_A;
		int M_B;
};
person operator+(person &p1,person &p2){
	person p3;
	p3.M_A=p1.M_A+p2.M_A;
	p3.M_B=p1.M_B+p2.M_B;
	return p3;
}//通过operator来实现
void test01(){
	person p1;
	p1.M_A=10;
	p1.M_B=10;
	person p2;
	p2.M_A=10;
	p2.M_B=10;
	person p3;
	p3=p1+p2;//本质调用p3=p1.operator+(p2) 简化版是p3=p1+p2
	cout<<p3.M_A<<" "<<p3.M_B<<endl;
}
int main()
{
	test01();
}

（2）可以通过成员函数来实现

using namespace std;
class person{
	public:
		person operator+(person &p){
			person p3;
			p3.M_A=this->M_A+p.M_A;
			p3.M_B=this->M_B+p.M_B;
			return p3;
		} //通过成员函数来实现运算符重载
		int M_A;
		int M_B;
};
void test01(){
	person p1;
	p1.M_A=10;
	p1.M_B=10;
	person p2;
	p2.M_A=10;
	p2.M_B=10;
	person p3;
	p3=p1+p2;//本质为p3=operator+(p1,p2)
	cout<<p3.M_A<<" "<<p3.M_B<<endl;
}
int main()
{
	test01();
}

（3）发生运算符重载同时也能实现函数重载

using namespace std;
class person{
	public:
		int M_A;
		int M_B;
};
person operator+(person &p1,person &p2){
	person p3;
	p3.M_A=p1.M_A+p2.M_A;
	p3.M_B=p1.M_B+p2.M_B;
	return p3;
}
person operator+(person &p1,int a){
	person p3;
	p3.M_A=p1.M_A+a;
	p3.M_B=p1.M_B+a;
	return p3;
} //作用域相同，形参不同，函数重载
void test01(){
	person p1;
	p1.M_A=10;
	p1.M_B=10;
	person p2;
	p2.M_A=10;
	p2.M_B=10;
	person p3;
	p3=p1+10;
	cout<<p3.M_A<<" "<<p3.M_B<<endl;
}
int main()
{
	test01();
}