C++类与对象笔记十二：运算符重载一：加号运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。自定义数据类型相加。

对加号运算符的重载：两种情况：

• 成员函数实现 加号 运算符重载
• 全局函数实现 加号 运算符重载

通过成员函数来实现，那么必须依托于实例对象来调用。

而基于全局函数，则不用考虑实例调用的情况。因此，传入的参数个数不同。

返回值类型：两个对象相加属性后，返回一个新的对象。因为加号可以不断往后累加，所以符合链式编程的规则，所以返回值与传入类型相同。

---

---

成员函数的加号运算符重载

我们可以自己写一个这样的成员函数：

Person PersonAddPerson(Person& p)
{
	Person temp;
	temp.m_A = this->m_A + p.m_A;
	temp.m_B = this->m_B + p.m_B;
	return temp;
}

调用方法：

Person p1;
p1.m_A = 20;
p1.m_B = 30;
Person p2(22, 33);
// 第一种方式：我们自己写一个加法函数。
Person temp = p1.PersonAddPerson(p2);

这是我们自己写的一个对象相加的函数。这个函数，不同的人，写出来，可能有不同的函数名，C++有一种更简单的写法，且可以统一名称的做法。使用operator。

Person operator+(Person& p)
{
	Person temp;
	temp.m_A = this->m_A + p.m_A;
	temp.m_B = this->m_B + p.m_B;
	return temp;
}

此时的调用方式:（本质调用方法）

Person p1;
p1.m_A = 20;
p1.m_B = 30;
Person p2(22, 33);
// 第一种方式：我们自己写一个加法函数。
//Person temp = p1.PersonAddPerson(p2);
// 第二种方式：我们使用Ｃ＋＋的方法。
Person temp = p1.operator+(p2);

还可以有一种简化写法：这就是C++中operator的好处。

Person p1;
p1.m_A = 20;
p1.m_B = 30;
Person p2(22, 33);
// 第一种方式：我们自己写一个加法函数。
//Person temp = p1.PersonAddPerson(p2);
// 第二种方式：我们使用Ｃ＋＋的方法。
// Person temp = p1.operator+(p2);
// 更简单的写法：简化写法：
Person temp = p1 + p2;   // 上面是其本质写法。
// 除了上面两种成员函数之外，还可以通过全局函数的方式：

---

---

全局函数的加号运算符重载

我们先自己写一个两对象相加的全局函数。作为全局函数，传入两个对象，返回一个新的对象。函数名称我们继续保留operator+这种方式。

Person operator+(Person p1, Person p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

调用方法也是两种，支持简写。

Person p1;
p1.m_A = 20;
p1.m_B = 30;
Person p2(22, 33);
//Person p3 = operator+(p1, p2);
简化写法：
Person p3 = p1 + p2;
cout << p3.m_A << ":" << p3.m_B;

全局函数和成员函数的加号重载，只能有一个，否则会报错:"operator+"不明确；有多个运算符“+”与这些操作数匹配。

---

---

运算符重载也可以发生函数重载

// 运算符重载 也可以发生函数重载
Person operator+(Person& p, int val)
{
	Person temp;
	temp.m_A = p.m_A + val;
	temp.m_B = p.m_B + val;
	return temp;
}

Person p1(11, 22);
Person p2 = operator+(p1, 60);
// 简化写法：
// Person p2  = p1 + 60;
cout << p2.m_A << "::" << p2.m_B << endl;

---

---

全码：

#include<iostream>
using namespace std;

class Person
{
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	Person PersonAddPerson(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}

	// 全局和成员函数的加号重载，只能有一个，否则会报错:"operator+"不明确；有多个运算符“+”与这些操作数匹配。
	//Person operator+(Person& p)
	//{
	//	Person temp;
	//	temp.m_A = this->m_A + p.m_A;
	//	temp.m_B = this->m_B + p.m_B;
	//	return temp;
	//}

public:
	int m_A;
	int m_B;
};

Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

// 运算符重载 也可以发生函数重载
Person operator+(Person& p, int val)
{
	Person temp;
	temp.m_A = p.m_A + val;
	temp.m_B = p.m_B + val;
	return temp;
}

void test01()
{
	Person p1;
	p1.m_A = 20;
	p1.m_B = 30;
	Person p2(22, 33);
	// 第一种方式：我们自己写一个加法函数。
	//Person temp = p1.PersonAddPerson(p2);
	// 第二种方式：我们使用Ｃ＋＋的方法。
	//Person temp = p1.operator+(p2);
	// 更简单的写法：简化写法：
	Person temp = p1 + p2;   // 上面是其本质写法。
	// 除了上面两种成员函数之外，还可以通过全局函数的方式：

	cout << temp.m_A << ":" << temp.m_B << endl;
}

void test02()
{
	Person p1;
	p1.m_A = 20;
	p1.m_B = 30;
	Person p2(22, 33);
	Person p3 = operator+(p1, p2);

	cout << p3.m_A << ":" << p3.m_B << endl;
}

void test03()
{
	Person p1(11, 22);
	Person p2 = operator+(p1, 60);
    // 简化写法：
    // Person p2  = p1 + 60;
	cout << p2.m_A << "::" << p2.m_B << endl;
}

int main()
{

	//test01();
	//test02();
	test03();

	system("pause");
	return 0;
}

---

对于内置的数据类型的运算符是不可改变的。