C++运算符重载

一.概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator *** 作符(参数列表)
注意：

1.不能通过连接其他符号来创建新的 *** 作符：比如operator@

2.重载 *** 作符必须有一个类类型或者枚举类型的 *** 作数

3.用于内置类型的 *** 作符，其含义不能改变，例如：内置的整型+，不 能改变其含义

4.作为类成员的重载函数时，其形参看起来比 *** 作数数目少1，因为成员函数的 *** 作符有一个默认的形参this，限定为第一个形参

6..* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。

这个经常在笔试选择题中出现。

以下面代码举例说明运算符重载：

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

//private:
	int _year;
	int _month;
	int _day;
};

 //函数名 operator *** 作符
 //返回类型 看 *** 作符运算后返回值是什么
 //参数， *** 作符有几个 *** 作数，他就有几个参数
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
bool operator>(const Date& d1, const Date& d2)
{
	if (d1._year > d2._year)
	{
		return true;
	}
	else if (d1._year == d2._year && d1._month > d2._month)
	{
		return true;
	}
	else if (d1._year == d2._year && d1._month == d2._month && d1._day > d2._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int main()
{
	Date d1(2022, 4, 10);
	Date d2(2022, 4, 15);
	cout << (d2 > d1) << endl;
	return 0;
}

        上面程序有个问题就是运算符重载函数变成了全局函数之后，就会对要求类的成员变量是共有的，那封装性就不能得到保证，数据的安全就不能得到保证了，为了解决这个问题，就需要将这个运算符重载函数在类内进行定义，而不是放在全局定义。

如果运算符重载函数在类内进行定义，那么该函数的第一个形参就是该对象的this指针，所以实际只需要声明一个形参就可以了。

具体实现如下所示：

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//这里需要注意的是，左 *** 作数是this指向的调用函数的对象
//bool operator>(Date* const this, const Date& d)
	bool operator>(const Date& d2)
	{
		if (_year > d2._year)
		{
			return true;
		}
		else if (_year == d2._year && _month > d2._month)
		{
			return true;
		}
		else if (_year == d2._year && _month == d2._month && _day > d2._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 4, 10);
	Date d2(2022, 4, 15);
	cout << (d2 > d1) << endl;
	d2 > d1;//	它等价于d1.operator>(d2);
	return 0;
}

 二.赋值运算符重载

赋值运算符主要有四点：

1.    参数类型
2.    返回值
3.    检测是否自己给自己赋值
4.    返回*this
5.    一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// bool operator=(Date* const this, const Date& d)
	// 此处返回类型是Date类的引用，是为了防止发生拷贝构造，
	// 并且返回的是this指向的对象，函数结束后不会被销毁,可以实现连续赋值（d1 = d2 = d3）
	Date& operator=(const Date& d)  
	{
	// 极端情况下自己给自己赋值就可以不同处理了，直接判断一下跳过
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 4, 10);
	Date d2(2022, 4, 15);
	Date d3(2022, 5, 10);

	// 一个已经存在的对象拷贝初始化一个马上创建实例化的对象
	Date d4(d1);  // 拷贝构造
	Date d5 = d1; // 拷贝构造

	// 两个已经存在的对象之间进行赋值拷贝
	d2 = d1 = d3; // d1.operator=(d3)
	//d1 = d3; // d1.operator=(d3)
	return 0;
}

        当我们不写赋值重载函数的时候，那么编译器就会生成默认赋值重载函数，它的作用跟默认拷贝构造函数类似，对于对象里的内置类型，按字节一个一个直接拷贝给另外一个对象的内置类型，而对于自定义类型，会直接调用它的默认赋值重载函数。

        需要注意的是，拷贝构造函数应用于 一个已经存在的对象拷贝初始化一个马上创建实例化的对象，而赋值运算符重载函数应用于两个已经存在的对象之间进行赋值拷贝。

        总结一下：对象会默认生成四个成员函数，分别是构造函数，析构函数，拷贝构造函数，赋值重载函数，其中构造和析构处理机制是基本类似的，拷贝构造和赋值重载处理机制是基本类似的。