C++|运算符重载基础

为什么要运算符重载？

对于内置数据类型，编译器知道如何进行运算，但是对于用户自定义的类，编译器不能进行自定义类型的运算。例如，两个整型变量可以通过“+”进行相加运算，但若是用户自定义类定义的两个对象进行相加，编译器不能不知道如何进行计算。此处就需要引入运算符重载。
运算符重载：对已有的运算符重新进行定义，赋予其另一种功能，以适用不同的数据类型。

加号运算符重载

实际上，对于大部分运算符，C++提供两种方式对运算符进行重载，包括成员函数和全局函数进行重载。而对于加号运算符就可使用以上两种方式进行重载，下面对加号运算符进行重载，实现两个对象相加属性后返回新的对象。

通过成员函数进行重载

class Person
{
public:
	Person operator+(Person& person)
	{
		Person temp;
		temp.m_A = this->m_A + person.m_A;
		temp.m_B = this->m_B + person.m_B;
		return temp;
	}
	int m_A = 0;
	int m_B = 0;
}

经上述运算符重载，即可进行以下运算：

int main()
{
	Person p1, p2;
	p1.m_A = 1;
	p1.m_B = 2;
	p2.m_A = 3;
	p2.m_B = 4;

	Person p3 = p1 + p2;
	cout << p3.m_A << endl;
	cout << p3.m_B << endl;
}

运算结果为：

通过全局函数进行重载

class Person
{
public:
	int m_A = 0;
	int m_B = 0;
};
Person operator+(Person& person1, Person& person2)
{
	Person temp;
	temp.m_A = person1.m_A + person2.m_A;
	temp.m_B = person1.m_B + person2.m_B;
	return temp;
}

与通过成员函数重载不同，此时没有this指针这样的工具，需要传两个参数进去，实现两个类的相加。同样执行上述程序，可以得到相同的结果。

左移运算符重载

采用何种方式重载

通常不会使用成员函数重载运算符<<，而使用全局函数重载运算符。下面将对此加以解释。

class Person
{
public:

	int m_A = 0;
	int m_B = 0;
};
int main()
{
	Person p;
	//cout << p;
}

欲想实现被注释掉的语句的功能，要知道对于<<运算符，使用了两个对象输出流ostream对象cout和Person类对象p，若同样使用成员函数进行重载：

class Person
{
public:
	void operator<<(ostream& os)
	{
		cout << m_A;
		cout << m_B;
	}
	int m_A = 0;
	int m_B = 0;
};
int main()
{
	Person p;
	p << cout;
	//cout << p;
}

意外地发现并未实现预期效果，因为这样重载出来的运算符，cout对象在右侧。这是因为，如果使用Person类成员函数来重载<<，Person类对象将会是第一个操作数，这意味着只能使用全局函数来重载运算符<<。

class Person
{
public:
	int m_A = 0;
	int m_B = 0;
};
void operator<<(ostream& os, Person& person)
{
	os << person.m_A;
	os << person.m_B;
}
int main()
{
	Person p;
	cout << p;
}

链式编程思想

上述方法虽然初步实现了运算符<<的重载，但若是在p后面追加<<endl，那么编译器就又不知该如何操作了，所以需要对此重载函数进行优化，也就是增加一个返回值，即输出流对象，这样就可以实现链式编程连续使用运算符<<。

class Person
{
public:
	int m_A = 0;
	int m_B = 0;
};
ostream& operator<<(ostream& os, Person& person)
{
	os << person.m_A;
	os << person.m_B;
	return os;
}
int main()
{
	Person p;
	cout << p << endl;
}

友元函数

此时看似已完整对运算符<<进行重载，但是通常建议成员变量为私有属性：

class Person
{
private:
	int m_A = 0;
	int m_B = 0;
};

但是这样就无法使用上述重载好的全局函数对成员变量进行访问，这里就需要引入友元类的技术。

class Person
{
	friend ostream& operator<<(ostream& os, Person& person);
private:
	int m_A = 0;
	int m_B = 0;
};

也就是此时的全局函数是Person类的友元函数，这样就私有成员就可以被此重载函数进行访问。下面对此重载进行完整的书写和测试：

#include <iostream>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& os, Person& person);
public:
	Person(int num1, int num2)
	{
		m_A = num1;
		m_B = num2;
	}
private:
	int m_A = 0;
	int m_B = 0;
};
ostream& operator<<(ostream& os, Person& person)
{
	os << "m_A=" << person.m_A << endl;
	os << "m_B=" << person.m_B << endl;
	return os;
}
int main()
{
	Person p(18, 20);
	cout << p << "Xar_" << endl;
}

输出结果：

小结：对左移运算符<<进行重载对自定义类进行输出；对于像左移运算符<<这种默认ostream类对象cout为第一个操作数的运算符，只能通过全局函数进行重载；为访问私有成员变量，在重载函数应定义为自定义类的友元。

重载限制

1.重载后的运算符必须至少有一个操作数是用户定义的类型，这将防止用户为标准内置类型重载运算符；
2.使用运算符时不能违反运算符原来的句法规则；
3.不能修改运算符的优先级；
4.不能创建新的运算符；
5.部分运算符不可重载：sizeof / . / .* / :: / ?:😕 typeid / const_cast / dynamic_cast / reinterpret_cast / static_cast；
6.部分运算符只能通过成员函数进行重载：= / () / [] / ->。