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;
}

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

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

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

三.小知识：自增运算符重载

假设现在对日期类的对象进行自增，那么就有两种方式，一种是前置加加，返回加加后的值，另一种是后置加加。但是前置加加和后置加加会调用相同的运算符重载函数，为了以示区分，前置加加调用operator++()，返回值是d2自加后的值；后置加加调用operator++(int)，返回值是d1自加前的值。

实现代码如下所示：

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << " " << _month << " " << _day << " " << endl;
	}

	Date& operator++()
	{
		_day++;
		return *this;

	}

	Date operator++(int)
	{
		Date res(*this);
		_day++;
		return res;

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


int main()
{
	Date d1(2022, 4, 9);
	Date d2(2022, 4, 10);
	Date d3 = d1++; //后置加加，相当于调用operator++(int)，返回值是d1自加前的值
	Date d4 = ++d2;//前置加加，相当于调用operator++()，返回值是d2自加后的值
	d3.print();
	d4.print();

	return 0;
}