0. 前言

本章首先提出一个问题以及对应的解决方法, 但是这种解决方法会有缺陷

以此引出运算符重载来改进这个解决方法, 目的是为了更好的理解运算符重载概念以及运算符重载解决了什么问题

之后详细说明运算符重载, 然后再运算符重载的基础上介绍赋值运算符重载

1. 概念引入

如何比较两个日期类对象的大小？

一个比较容易想到的解法是用一个函数去实现, 如下例

#include <iostream>
using namespace std;

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

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

bool Compare(const Date& x1, const Date& x2)
{
	if (x1._year < x2._year)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month < x2._month)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month == x2._month && x1._day < x2._day)
	{
		return true;
	}
	return false;
}

int main()
{
	Date d1(2025, 4, 25);
	Date d2(2023, 5, 25);
	cout << Compare(d1, d2) << endl;
}

0表示假, d1 大于 d2

实际上, 这种解法并不好, 因为可读性很差, 看代码的人需要具体去看Compare函数的实现, 才能看懂这段代码Compare(d1, d2)在做什么

如果是这样 d1 < d2, 那么看代码的人可以清楚的明白这是在做比较, d1是否小于d2，这样就增强了可读性

但是, 自定义类型是不能使用运算符的, 因为编译器无法识别, 不能转换成指令

所以C++引入了运算符重载, 为了让自定义类型可以像内置类型一样使用运算符

下面来看一下, 如何使用运算符重载优化解法

#include <iostream>
using namespace std;

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

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

// 重载运算符<
bool operator<(const Date& x1, const Date& x2)
{
	if (x1._year < x2._year)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month < x2._month)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month == x2._month && x1._day < x2._day)
	{
		return true;
	}
	return false;
}

int main()
{
	Date d1(2025, 4, 25);
	Date d2(2023, 5, 25);
	cout << (d1 < d2) << endl;
}

如图, 重载了运算符<, 对象之间就可以使用运算符<进行比较

这样方便使用, 同时又提高了可读性

下面详细说明运算符重载的概念与特性

2. 运算符重载

概念

运算符重载是具有特殊函数名的函数, 具有返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似

运算符重载的定义: 返回值类型 operator操作符(参数列表)

需要注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重载

在概念中提到, 运算符重载是一个函数, 那么在概念引入例子中为什么可以这样(d1 < d2) 调用函数 ?

实际上, (d1 < d2) == operator<(d1, d2), 它们最终会转换为一样的指令

因为编译器执行(d1 < d2), 会去自动调用operator<(d1, d2), 所以最终的指令都是一样的

概念引入的例子还有没有什么问题?

#include <iostream>
using namespace std;

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

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

// 重载运算符<
bool operator<(const Date& x1, const Date& x2)
{
	if (x1._year < x2._year)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month < x2._month)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month == x2._month && x1._day < x2._day)
	{
		return true;
	}
	return false;
}

int main()
{
	Date d1(2025, 4, 25);
	Date d2(2023, 5, 25);
	cout << (d1 < d2) << endl;
}

还有几个问题, 需要一个一个来看

类中的成员变量, 应该设置为私有, 不允许在类外面访问

但是将成员变量设置为私有, 又会出现新的问题, 如上图, 在类外无法访问成员

解决这个问题, 可以把重载运算符函数放在类里面, 作为成员函数, 这样就可以通过this指针访问私有成员变量

但是这样做又会出现新的问题, 如上图

出现问题的原因是, operator<运算符函数只能有两个参数, 而这里有三个 ( x1 + x2 + 隐藏的this指针)

所以需要去掉一个参数, 如下

#include <iostream>
using namespace std;

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

	// 重载运算符<
	bool operator<(const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}
		return false;
	}

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


int main()
{
	Date d1(2025, 4, 25);
	Date d2(2023, 5, 25);
	cout << (d1 < d2) << endl;
	cout << d1.operator<(d2) << endl;
}

如图, 这样就解决了问题

注意: (d1 < d2) == d1.operator<(d2) d1调用成员函数operator<

3. 赋值运算符重载

概念引入

有了运算符重载的基础, 直接先看一个使用赋值运算符的例子

#include <iostream>
using namespace std;

class Date
{
public:
	// 构造
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 拷贝构造
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	bool operator<(const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}
		return false;
	}

	// 赋值运算符重载
	void operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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


int main()
{
	Date d1(2025, 4, 25);
	Date d2(2023, 5, 25);
	d1 = d2;
	//d1.operator=(d2);
}