look here

• • • 运算符重载
    • 赋值运算符重载
    • • 细节总结：
• – the End –

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，其目的就是让自定义类型可以像内置类型一样可以直接使用运算符进行操作。运算符重载，就是对已有的运算符赋予多重含义，使同一运算符作用于不同类型的数据时产生不同的行为。运算符重载的目的是使得 C++ 中的运算符也能够用来操作对象。

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

函数原型：返回值 operator运算符(参数列表)
格式如下：

<返回类型说明符> operator <运算符符号>(<参数表>)
{
 
     <函数体>
 
}

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

下面来简单写一个例子

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
public://原本这里应该是private,但是这样运算符重载会访问不了
//private:
	int _year;
	int _month;
	int _day;
};
//一、参数类型设置为引用，并用const进行修饰
 //由于是自定义类型传参，我们若是使用传值传参，会额外调用一次拷贝构造函数，所以函数的参数最好使用引用传参
 //其次，对于参数，我们在函数体内不会对其进行修改，所以最好加上const进行修饰。
bool operator==(const Date& x1,const Date& x2)
	{
		return x1._year == x2._year
			&& x1._month == x2._month
			&& x1._day == x2._day;
	}
int mian()
{
	Date d1(2020, 10, 22);
	Date d2(2021, 5, 22);
	Date d3(2023, 3, 22);

	//运算符默认都是给内置类型变量用的
	//自定义类型的变量想用这些运算符，得自己进行运算符重载
	//运算符重载的意思就是我们自己去写一个函数定义实现这里运算符的行为
	d1 == d2;
	return 0;

}

此时通过运算符重载就起到了判断日期类相等的作用，但是却把原先类中的private改成了public,如果不改变访问限定符，就会面临访问私有成员变量的问题 ->如何解决？

我们可以把运算符重载当作成员函数放在日期类中，这样就不存在访问受限了

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

bool operator==(const Date& x1,const Date& x2)
	{
		return x1._year == x2._year
			&& x1._month == x2._month
			&& x1._day == x2._day;
	}
public://原本这里应该是private,但是这样运算符重载会访问不了
//private:
	int _year;
	int _month;
	int _day;
};

但是我们会看到报错：

这是因为:

运算符重载为全局函数时，参数的个数等于运算符的目数（即操作数的个数）；运算符重载为成员函数时，参数的个数等于运算符的目数减一。

我们来解释一下：
运算符重载的参数要求是参数的个数等于运算符的目数（即操作数的个数），在运算符重载为成员函数时，除了我们看到的两个参数，还有一个是隐含的this指针，这就导致了报错的原因。

所以我们对函数重载做以下修改：

bool operator==(const Date& x)//bool operator==(Date* this,const Date&x)
	{
		return _year == x_year
			&& _month == x_month
			&& _day == x_day;
//实际上是：
//	    return this->_year == x._year
//			&& this->_month == x._month
//			&& this->_day == x._day;*/
	}

再次调用：

 d1==d2;
//或者 d1.operator==(d2);

上面两种调用方式实际是一样的，我们从汇编角度看一下：

了解原理以后，我们再来一个：

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

赋值运算符重载

根据运算符重载规则我们来进行赋值（=）运算符重载。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//赋值运算符重载
	void operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()//输出
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	private:
	//public:
	int _year;
	int _month;
	int _day;	
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	d1 = d3;
	d1.Print();
	d3.Print();
	//赋值运算符重载：用于两个以及那个定义出来的对象间拷贝复制
	//拷贝构造：用一个已经存在的对象去构造初始化另一个即将创建的对象
	//拷贝构造：d3=d5;
	return 0;

}

运行结果：

我们可以看到将d3赋值给了d1
但是仅仅这样还不够，我们知道赋值的特性是可以连续赋值，比如：

d1=d2=d3;
//将d3赋值给d2，然后把d2作为返回值赋值给d1

我们来看是否可以：

很显然不行，因为赋值重载没有设置返回值,以 d1=d2=d3;为例，d2无法作为返回值赋值给d1，所以我们做以下修改：

Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

细节总结：

一、参数类型设置为引用，并用const进行修饰

由于是自定义类型传参，我们若是使用传值传参，会额外调用一次拷贝构造函数，所以函数的第二个参数最好使用引用传参（第一个参数是默认的this指针）。其次，第二个参数，即赋值运算符的右操作数，我们在函数体内不会对其进行修改，所以最好加上const进行修饰。

二、函数的返回值使用引用返回
 我们若是只以d2 = d1这种方式使用赋值运算符，赋值运算符重载函数就没必要有返回值，因为在函数体内已经通过this指针对d2进行了修改。但是为了支持连续赋值，即d3 = d2 = d1，我们就需要为函数设置一个返回值了，而且很明显，返回值应该是赋值运算符的左操作数，即this指针指向的对象。
 和使用引用传参的道理一样，为了避免不必要的拷贝，我们最好还是使用引用返回，因为此时出了函数作用域this指针指向的对象并没有被销毁，所以可以使用引用返回。

三、引用返回的是*this
 赋值操作进行完毕时，我们应该返回赋值运算符的左操作数，而在函数体内我们只能通过this指针访问到左操作数，所以要返回左操作数就只能返回*this。
四、赋值前检查是否是给自己赋值
 若是出现d1 = d1，我们不必进行赋值操作，因为自己赋值给自己是没有必要进行的。所以在进行赋值操作前可以先判断是否是给自己赋值，避免不必要的赋值操作。

– the End –

以上就是我分享的【运算符重载(赋值运算符重载)原来是这么一回事】相关内容，感谢阅读！

关注作者，持续阅读作者的文章，学习更多知识！
https://blog.csdn.net/weixin_53306029?spm=1001.2014.3001.5343

2022.1.8
————————————————