探索C++赋值运算符重载的内部机制：手把手教你精通

---

W...Y的主页 😊

代码仓库分享💕 

---

🍔前言：

前一篇博客中我们已经了解并学习了初始化和清理模块中的构造函数与析构函数，还有拷贝复制中的拷贝复制函数，它们都是类与对象中重要的成员，今天我们要来讲一下拷贝复制模块中另一个非常重要的内容——赋值重载，但是在学习赋值重载的同时我们应该先学习运算符重载，话不多说我们直接开始！

目录

赋值运算符重载

运算符重载

 赋值运算符重载

---

赋值运算符重载

运算符重载

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

#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// Date(const Date& d)  // 正确写法
	void print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	Date(const Date& d)  // 错误写法：编译报错，会引发无穷递归
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2022,10,23);
	int x = 1; 
    int y = 2;
    bool ret = x > y;
	return 0;
}

 上图是比较的反汇编代码，我们可以看出编译器可以直接做出运算符判断。

一般情况下，我们去比较内置类型都非常容易去比较，因为内置类型都是一些基本变量int、char……我们可以直接使用运算符 ==、<、>等等去比较。但是自定义类型我们应该如何处理呢？

一般情况下我们可以自己创建一个比较函数进行比较：

//判断前面日期是否比后面大
//大返回true，小返回false
bool Greater(Date x, Date y)
{
	if (x._year > y._year)
	{
		return true;
	}
	else if (x._year == y._year && x._month > y._month)
	{
		return true;
	}
	else if (x._year == y._year && x._month == y._month && x._day > y._day)
	{
		return true;
	}
 
	return false;
}

将此函数放入到类中才可以进行私有数据访问，要不就将基本数据公有化！

上述函数可以轻松解决比大小的问题，但是还是有许多缺陷。比如：函数名的不规范就会导致我们不理解函数的作用。所以对于内置类型的比较C++针对起名字做出了一下规定：

函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。 

那针对以上函数我们就可以这样修改：

bool operator>(const Date& x, const Date& y)
{
	if (x._year > y._year)
	{
		return true;
	}
	else if (x._year == y._year && x._month > y._month)
	{
		return true;
	}
	else if (x._year == y._year && x._month == y._month && x._day > y._day)
	{
		return true;
	}
 
	return false;
}

在参数选择时，我们选择引用而不选择直接传参，这样可以节约时间效率，不用调用拷贝构造函数。 

 这样做我们用户一眼就可以看出此函数的作用，是用来比大小的函数。但是这样去调用函数时函数名还是太长了，而且不直白不美观，所以我们在使用时可以使用非常简单的方式进行调用：

bool ret1 = d1 > d2;

只需要一个运算符就可以调用此函数，是不是非常方便呢！编译器可以帮助我们将这句话转变为，调用函数的语句。

注意：运算符重载与函数重载中都有重载二字，但是绝对是没有任何关系的，函数重载是可以允许参数不同的同名函数，运算符重载是自定义类型可以直接使用运算符。不是姓“张”的都有血缘关系。

但是当我们万事俱备之后进行编译却还是出现报错： 这是为什么呢？

为什么会多一个参数呢？哪里多了？成员参数都会有一个隐藏的参数this指针。所以参数不匹配导致程序出问题。相当于我们在调用函数时使用了两个参数，而设定的参数中却有三个！

我们应该怎么解决问题呢？删一个即可。

#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// Date(const Date& d)  // 正确写法
	void print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	//Date(const Date& d)  // 错误写法：编译报错，会引发无穷递归
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	bool operator>(const Date& y)
	{
		if (_year > y._year)
		{
			return true;
		}
		else if (_year == y._year && _month > y._month)
		{
			return true;
		}
		else if (_year == y._year && _month == y._month && _day > y._day)
		{
			return true;
		}
 
		return false;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
//判断日期是否相等
//bool Greater(Date x, Date y)
//bool Compare1(Date x, Date y)
 
 
int main()
{
	Date d1;
	Date d2(2022,10,23);
	/*d1 == d2;
	d1 > d2;*/
	bool ret1 = d1 > d2;
	int x = 1, y = 2;
	bool ret = x > y;
	return 0;
}

 我们将参数删除一个即可，编译器看就会转换成d1.operator(d2)在进行转换成d1.operator(&d1,d2)即可，地址就是this指针指向的内容。

我们学明白了运算符重载，那么在进行赋值运算符重载就非常easy了。

 赋值运算符重载

赋值运算符重载格式
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

class Date
{
public :
Date(int year = 1900, int month = 1, int day = 1)
 {
    _year = year;
    _month = month;
    _day = day;
 }
Date (const Date& d)
 {
    _year = d._year;
    _month = d._month;
    _day = d._day;
 }
Date& operator=(const Date& d)
{
if(this != &d)
   {
      _year = d._year;
      _month = d._month;
      _day = d._day;
   }
   
    return *this;
}
private:
    int _year ;
    int _month ;
    int _day ;
};

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

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
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;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
运算符重载只能是类的成员函数。 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注
意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符
重载完成赋值

class Time
{
public:
Time()
{
_hour = 1;
_minute = 1;
_second = 1;
}
Time& operator=(const Time& t)
{
if (this != &t)
{
_hour = t._hour;
_minute = t._minute;
_second = t._second;
}
return *this;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d1;
Date d2;
d1 = d2;
return 0;
}

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实
现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
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);
s1.Push(3);
s1.Push(4);
Stack s2;
s2 = s1;
return 0;
}

 注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必
须要实现。

---

以上就是赋值运算符重载全部内容！！！感谢大家观看。