C++类和对象进阶：运算符重载深度详解

C++类和对象进阶：运算符重载

前言
引入
运算符重载
- 定义
- 语法
- 注意事项
- 重载为全局函数
- 重载为成员函数
默认赋值运算符重载(默认成员函数)
编译器自己生成的赋值运算符重载函数
- 总结默认赋值运算符重载
总结

前言

在C++中，运算符重载允许我们为自定义类型赋予与内置类型相似的操作方式，极大提升了代码的可读性和灵活性。本文将深入探讨运算符重载的规则与实现，并重点分析默认成员函数之一的赋值运算符重载函数。

在这里插入图片描述

引入

class Date {
public:Date(int year = 2025, int month = 2, int day = 22) {this->_year = year;this->_month = month;this->_day = day;}
private:int _year;int _month;int _day;
};
int main(){Date d1, d2;//d1 == d2;	// 若无运算符重载，这样的写法未定义。//if(d1 > d2){;}	// 若无运算符重载，这样的写法未定义。
}

思考以下场景：
如果想

1. 比较两个日期类对象是否相等
2. 两个日期相减的运算来计算相差的天数
3. 计算一个日期100天后是什么日期

C++为了满足自定义类型中以上类似需求并为了增强代码的可读性，引入了运算符重载。

运算符重载

定义

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

语法

函数名字为：关键字operator后面接需要重载的运算符符号。
例如要对==进行重载

//假定返回值为bool
bool operator==(int x, int y);	//声明

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

注意事项

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

总结以上内容：

函数格式：返回类型 operator运算符(参数列表)
关键限制：
1. 只能重载C++中已有的运算符，不能创造新的运算符。
2. 重载运算符主要是针对自定义类型的，因此operator必须有一个类类型参数.
3. 不能改变运算符对内置类型操作的原始含义。
4. 要重载的运算符有几个操作数，operator中就有几个参数(算上this指针)
5. 以下运算符不可重载：.* :: sizeof ?: .。

重载为全局函数

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;elsereturn false;
}
class Date {
public:Date(int year = 2025, int month = 2, int day = 22) {this->_year = year;this->_month = month;this->_day = day;}
//private:	//暂时设为public,是为了让全局重载的<可以访问到类内的成员变量
public:int _year;int _month;int _day;
};
int main(){Date d1(2025, 2, 12);Date d2(2024, 2, 12);cout << (d2 < d1) << endl;//d2 < d1 会被编译器转换成 d2.operator(d1),本质上是调用函数return 0;
}

在这里插入图片描述

注意：d1 < d2, 重载后的 < ，Date类对象使用<号时，左操作数是这里的d1，右操作数是这里的d2

这里会发现运算符重载成全局函数，需要成员变量是公有的，那么问题来了，封装性如何保证？

为解决这一问题，我们可以重载成成员函数。

重载为成员函数

//运算符重载
class Date {
public:Date(int year = 2025, int month = 2, int day = 22) {this->_year = year;this->_month = month;this->_day = day;}//操作符是几个操作数，operator函数就有几个参数(应该包括上隐含的this指针参数)//也可以全局重载，但在类内重载更方便，可以直接访问私有成员bool operator<(const Date& d) {	//自定义类型，最好传引用，类内不能通过形参d修改原变量，加上constif (this->_year < d._year)return true;else if (this->_year == d._year && this->_month < d._month)return true;else if (this->_year == d._year && this->_month == d._month && this->_day < d._day)return true;elsereturn false;}
private:int _year;int _month;int _day;
};

bool operator<(const Date& d);，这里需要注意的是，由于第一个形参是this, 左操作数是*this，是调用函数的对象，右操作数是传入的另一个对象。
是否需要重载运算符，要看这些运算符对该类型是否有意义

对比分析：

特性	成员函数形式	全局函数形式
访问权限	可直接访问私有成员	需友元声明
左操作数类型	必须是类对象	任意类型
隐式this参数	有	无
对称性操作符	不便于处理	更适合（如<<流操作符）

掌握以上规则，我们便学会了如何对运算符进行重载。

接下来来看六大默认成员函数中的：赋值运算符重载。

默认赋值运算符重载(默认成员函数)

我们早已知道，赋值运算符重载是类内的一个默认成员函数。

C语言中自定义类型可以完成赋值操作(例如：同类型结构体之间的赋值)，C++中的class同样支持赋值操作，只不过C++对这一行为进行了优化与升级。

赋值运算符重载格式
- 参数类型：const T&，传递引用可以提高传参效率
- 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
- 检测是否自己给自己赋值，允许自己给自己进行赋值，但此时不需要拷贝，直接返回当前对象本身。
- 返回*this ：要复合连续赋值的含义

//运算符重载
class Date {
public:Date(int year = 2025, int month = 2, int day = 22) {this->_year = year;this->_month = month;this->_day = day;}//操作符是几个操作数，operator函数就有几个参数(应该包括上隐含的this指针参数)//也可以全局重载，但在类内重载更方便，可以直接访问私有成员bool operator<(const Date& d) {	//自定义类型，最好传引用，类内不能修改，加上constif (this->_year < d._year)return true;else if (this->_year == d._year && this->_month < d._month)return true;else if (this->_year == d._year && this->_month == d._month && this->_day < d._day)return true;elsereturn false;}//赋值运算符重载是默认成员函数，编译器会自己生成， 不能写成全局的，Date& operator=(const Date& d) {//if (*this != d)	// 这样子比较，代价有点大，将 != 重载后是可以实现的，但是没必要if (this != &d) {	//防止这样的赋值 d1 = d1   如果自己给自己赋值，可以不复制this->_year = d._year;this->_month = d._month;this->_day = d._day;}return *this;	//返回对象的别名，出了作用域，*this生命周期还在}
private:int _year;int _month;int _day;
};

注意：赋值运算符只能重载成类的成员函数不能重载成全局函数。

原因：

赋值运算符重载成全局函数时，就没有this指针了，无法访问类内的私有变量，需要给两个参数，如下示例：

Date& operator=(Date& left, const Date& right){if (&left != &right){left._year = right._year;left._month = right._month;left._day = right._day;}return left;}

赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
运算符重载只能是类的成员函数。

编译器自己生成的赋值运算符重载函数

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符
重载完成赋值。

观察以下程序

class Stack{
typedef int DataType;
public:Stack(size_t capacity = 10){_array = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _array){perror("malloc申请空间失败");return;}_size = 0;_capacity = capacity;}void Push(const DataType& data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){if (_array){free(_array);_array = nullptr;_capacity = 0;_size = 0;}}
private:DataType *_array;size_t _size;size_t _capacity;
};
int main(){Stack s1;s1.Push(1);s1.Push(2);Stack s2;s2 = s1;return 0;
}

以上程序会报错
报错原因和往期文章中的拷贝构造函数类似。

main函数结束时，会调用Stack中的析构函数对s1和s2两个对象进行析构。
编译器默认生成的赋值运算符重载进行的是值拷贝。由于进行了s2 = s1的赋值操作，赋值过后, s2和s1中变量_array存放了同一块空间的地址。
main函数结束后，会调用st1和st2的析构函数，由于地址相同，则会对同一块空间析构两次(对同一块空间free两次)。因此会报错。

总结默认赋值运算符重载

默认成员函数：默认赋值运算符重载是默认成员函数
重载特性：只能重载成类的成员函数不能重载成全局函数,若定义为全局函数会与编译器默认生成的冲突。
拷贝方式：编译器生成的默认赋值运算符重载函数完成字节序的值拷贝了(浅拷贝)
需要手动实现的场景：如果类中未涉及到资源管理(在堆区申请空间)，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要手动实现深拷贝。

总结

特性	运算符重载	赋值运算符重载
`必要性`	增强代码可读性	资源管理的必要手段
`默认行为`	无	浅拷贝
`典型应用场景`	算术运算、比较运算	对象复制、资源管理
`实现要点`	操作数类型、返回值优化	深拷贝、自赋值检查