? ? 运算符重载函数(除赋值运算符之外)和赋值运算符重载函数均是 非默认 的，如果在类体中显式实现了赋值运算符重载函数的话，编译器就不会在类体中自动生成一个赋值运算符重载函数了，否则，编译器会在类体中自动生成一个赋值运算符重载函数、

首先给定一个日期类：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022,7,13);
	Date d2(2022,7,14);
	d1.Print();
	d2.Print();
	return 0;
}

? ? ?那么能不能进行对象d1和对象d2的比较呢，或者是对 对象d1和对象d2分别进行运算呢 ？即，能不能使用运算符对两个对象d1和d2进行操作呢，如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022,7,13);
	Date d2(2022,7,14);
	//1、能否通过下面的代码来 比较 两个对象d1和d2呢？、
	//答案是不可以的,因为,其中 >,==,< 这三者均属于运算符、 
	if (d1 > d2)
	{
		cout << ">" << endl;
	}
	else if (d1 == d2)
	{
		cout << "==" << endl;
	}
	else
	{
		cout << "<" << endl;
	}
	//2、能否通过下面的代码对 对象d1或对象d2进行 运算 呢？
	//答案是不可以的,其中 ++,+,- 这三者均属于运算符、 
	d1++;
	d1 + 100;
	d1 - 100;

	d1.Print();
	d2.Print();
	return 0;
}

注意：

? ? 不管是在C语言中，还是在C++中，对于内置类型都可以直接使用各种运算符，因为内置类型是系统自己定义的，所以系统是知道如何对他们进行各种运算符操作的，比如系统是知道如何去比较这里的两个对象d1和d2中的年，月，日的，按照二进制位去比较即可，这是当操作数均是内置类型的时候，但是对于自定义类型而言的话，是不可以直接使用各种运算符的，这是因为，自定义类型是我们自己定义的，系统是不知道如何对他们进行各种运算符操作的，需要我们自己设定规则，所以，为了让自定义类型也可以使用大部分的运算符，这就引出了运算符重载的概念，从而去间接的使用这大部分的运算符，要知道，此处的运算符重载和之前所谓的函数重载不是一个概念，所谓运算符重载就是重新去定义或者说是控制某些大部分运算符的使用规则，当操作数均是内置类型时，就可以直接使用各种运算符，当操作数只要出现了自定义类型就不可以直接使用各种运算符、

? ?? 由此，C++编译器提供了一个新的关键字operator，然后该关键字后面跟上运算符，这样就可以重载这个运算符的使用规则，该运算符重载后的使用规则，可以在该运算符重载函数的函数体内自己去设定即可，运算符重载就是运算符重载函数，如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
//1、运算符重载函数,其中 operator== 是该运算符重载函数的函数名,即: operator运算符 、
//2、运算符重载函数的参数的个数是由该要被重载的运算符的操作数的个数决定的,比如:运算符==就有两个操作数,所以该运算符重载函数就有
//两个形参,因为运算符==是双操作数的运算符,常见的单操作数的运算符有:++,-- 等等、
//3、运算符重载函数的返回类型(返回值)是根据该被重载的运算符的运算结果所决定的,比如,运算符==的结果就是:相等或不相等(真和假的布尔值),则该运算符重载函数的
//返回类型就是:bool、

//全局函数、
bool operator==(Date d1, Date d2)
{
	//该运算符重载函数的函数体内具体进行的操作就不再是系统语法规定的了,而是由我们自己去定义、
	//此处的_year,_month,_day都属于内置类型,是可以直接使用各种运算符进行操作的、
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 13);
	//若是调用该全局函数 operator== 的话,应该按照如下方式进行调用:
	if (operator==(d1, d2))
	{
		cout << "==" << endl;
	}

	以此为例:
	//if (d1 == d2)
	//{
	//	cout << "==" << endl;
	//}
	d1.Print();
	d2.Print();
	return 0;
}

? ? 上述代码会报错，这是因为，类体中的三个内置类型的类成员变量均是私有的，在类外没办法直接访问到他们，现在有三种方式可以解决上述问题：

1.?可以手动的把类体中的这三个内置类型的类成员变量的属性改为公有，首先要知道，类体中的类成员变量不是必须设置为私有或保护的，但是通常情况下都是设置成私有或保护的，这种方法就违背了当初把他们设置成私有或保护的意愿，所以不采用这种方法、

2.?在类体中实现公有的函数接口，然后在类外访问该公有的函数，通过该公有的函数来访问类体中私有或保护属性的类成员变量，再把这些类成员变量通过该公有的函数返回出来，在类外对这些返回出来的类成员变量进行接收、

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
	int GetYear()
	{
		return _year;
	}
	int GetMonth()
	{
		return _month;
	}
	int GetDay()
	{
		return _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
//全局函数、
bool operator==(Date d1, Date d2)
{
	return d1.GetYear() == d2.GetYear() && d1.GetMonth() == d2.GetMonth() && d1.GetDay() == d2.GetDay();
}
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 14);
	//若是调用该全局函数 operator== 的话,应该按照如下方式进行调用:
	if (operator==(d1, d2))
	{
		cout << "==" << endl;
	}
	else
	{
		cout << "！=" << endl;
	}

	以此为例:
	//if (d1 == d2)
	//{
	//	cout << "==" << endl;
	//}
	d1.Print();
	d2.Print();
	return 0;
}

3.?使用友元函数，但是这种方法不太好，会破坏封装、

4.?直接把该全局的运算符重载函数放在类体中去，这样的话，在该运算符重载函数的函数体内对类中的类成员变量进行访问时就不会再受到访问限定符的限制、

? ? 此时，为了方便演示，就先使用方法1，但实际中并不会这样操作，一般都是通过第4种方法进行操作，但由于在使用方法4时，还会涉及到其他内容，具体在后面进行阐述，当前不方便使用方法4，还需要做一些其他的改动，所以目前就先使用方法1，从而方便更好的演示，代码如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
	//设为公有public:、
	int _year;
	int _month;
	int _day;
};
//全局函数、
方法一、
//bool operator==(Date d1, Date d2)
//{
//	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
//}
//方法二、
bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 13);
	//若是调用该全局函数 operator== 的话,应该按照如下方式进行调用:
	if (operator==(d1, d2))
	{
		cout << "==" << endl;
	}
	else
	{
		cout << "！=" << endl;
	}

	//以此为例:
	if (d1 == d2)
	{
		cout << "==" << endl;
	}
	d1.Print();
	d2.Print();
	return 0;
}

? ? 通过上面可知，如果按照上述写法的话，其实感觉不出来在使用运算符重载函数，而是和调用普通的全局函数没什么区别，相比之下这样的运算符重载函数反而更加麻烦了，那么我们为什么不自己写一个普通的全局调用函数来实现呢，但其实上，如下所示：

    //一、
    //if (operator==(d1, d2))
	//{
	//	cout << "==" << endl;
	//}

    //二、
	if (d1 == d2)
	{
		cout << "==" << endl;
	}

? ? 在使用上述方法二时，也能正常打印出 == ，这是普通的全局调用函数所不能实现的，其实，在本质上，当使用这里的方法二时，就等价于在使用这里的方法一：

    //二、
    if (d1 == d2)    //if (operator==(d1, d2))
    {
    	cout << "==" << endl;
    }

? ? 此时，假设d1和d2都是内置类型，当编译器看到d1和d2时，由于这两者都是内置类型，则编译器就直接转换成指令对他们进行运算符的操作，但当编译器看到对象d1和d2时，由于这是自定义类型，所以编译器会先去类体中看一下是否定义了运算符重载函数，如果发现已经定义了运算符重载函数的话，那么就不会再去类体外的全局区域内查找是否定义了运算符重载函数，那么此时编译器就把?if (d1 == d2)? 自动进行转换为：if (d1.operator==(d2)) ，根据该代码再去自动调用对应的运算符重载函数，如果编译器在类体中没有发现运算符重载函数的定义，那么编译器才会再去类体外的全局区域查找运算符重载函数的定义，如果发现了，则编译器会自动的把?if (d1 == d2)? 转化为? if (operator==(d1, d2))，根据该代码再去自动调用对应的运算符重载函数，若在类体外的全局区域也没有定义运算符重载函数的话，那么编译器就会报错、

? ? 而此时，当编译器看到对象d1和d2时，由于这是自定义类型，?所以编译器会先去类体中看一下是否定义了运算符重载函数，发现没有定义运算符重载函数，那么此时编译器就会再去类体外的全局区域查找运算符重载函数的定义，发现已经定义了，所以就会自动的把? if (d1 == d2)? 转换为??if (operator==(d1, d2))，根据该行代码再去自动的调用对应的运算符重载函数、

? ? 当我们在类体外的全局区域中定义了运算符重载函数(全局函数)之后，就不再使用方法一，而是可以直接使用方法二了，此时，方法一只是告诉我们可以这样使用，但是我们一般不使用这种方法，而是直接使用方法二，就像直接对内置类型那样使用各种运算符一样、

? ? 但是在实际中，我们不会写成上述代码这样，因为，我们不会使用方法1，其次，方法2也比较麻烦，使用友元函数还会破坏封装，目前最好的方式就是使用最后一种方法，即方法4，把运算符重载函数(全局函数)放在类体中去变成类成员函数(非静态)，但是直接拷贝进行会发现，编译器会报错，说是：二进制"operator=="的参数过多，这是为什么呢 ? 根据上面的总结，现在该类体中的运算符重载函数(非静态的类成员函数)有2个参数，按理说是不应该报错的啊，实际上，此时的运算符重载函数就由普通的全局函数变成了类成员函数，且是非静态的，故该函数的第一个形参位置上会多了一个this指针，要知道：类的6个默认类成员函数中均包含有this指针，析构函数说是没有参数，但其实析构函数的形参中也有一个隐藏的this指针，并且，拷贝构造函数也说是只有一个形参，但实际上他的形参列表中的第一个位置上也有一个隐藏的this指针，由此可知，所以此处会进行报错，实际上，该运算符重载函数(非静态的类成员函数)的形参列表中已经有了3个参数，但是由于运算符 == 的操作数只有两个，所以该运算符重载函数(非静态的类成员函数)就必须只能有两个参数，现在就要少写一个参数(除隐藏的this指针外)，就默认把左操作数对应的参数舍弃掉，代码如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}

	//1、
	//bool operator==(Date d2)
	//{
	//	return _year == d2._year && _month == d2._month && _day == d2._day;
	//}

	//2、
	优改为:
	//bool operator==(Date d)    //bool operator==(Date* const this,Date d) 
	//{	
	//	return _year == d._year && _month == d._month && _day == d._day;
	//}

	//3、
	//上述代码中,在传参时可以使用传值,传址,还可以使用传引用的方法,并没有限制某一种方法不可使用,但是由于C++中规定自定义类型的对象在传值传参时会调用拷贝构造函数,我们要尽量避免调用拷贝构造函数,
	//所以就不使用传值的形式进行传参,而使用传址传参和传引用传参均不会调用拷贝构造函数,而传址传参又不如传引用传参,所以应使用传引用传参,要记住,自定义类型的对象在 传参和返回 时尽量避免调用拷贝构造函数
	//虽然上述代码可以完成任务,但是不如使用传引用传参好,当三种方法都可以使用时,优先选择传引用传参,故再次优化为:
	bool operator==(const Date& d)    //bool operator==(Date* const this,const Date& d) 
	{
		return _year == d._year && _month == d._month && _day == d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 13);

	//一、
	if (d1.operator==(d2))  //把自定义类型对象d1的地址传给了隐藏的this指针、
	{
		cout << "==" << endl;
	}

	//二、
	if (d1 == d2)     //if (d1.operator==(d2))      //if (d1.operator==(&d1,d2))
	{
		cout << "==" << endl;
	}
	d1.Print();
	d2.Print();
	return 0;
}

? ? 此时，当编译器看到对象d1和d2时，由于这是自定义类型，?所以编译器会先去类体中看一下是否定义了运算符重载函数，发现已经定义运算符重载函数，此时就不会再去类体外的全局区域查找是否定义了运算符重载函数，故编译器自动的把? if (d1 == d2)?进行了转换为：if (d1.operator==(d2)) ，然后再去调用对应的运算符重载函数、

? ? 如果在类体中和在类体外的全局域中都定义了运算符重载函数的话，编译时可以通过的，是因为两者在不同的作用域中，所以函数名一样也是可以的，当编译器看到对象d1和d2时，由于这是自定义类型的对象，所以编译器会先去类体中看一下是否定义了运算符重载函数，发现已经定义运算符重载函数，此时不会再去类体外的全局区域查找是否定义了运算符重载函数，编译器现在就会自动的把? if (d1 == d2)?进行了转换为：if (d1.operator==(d2)) ，然后再去调用对应的运算符重载函数、

拓展：

?请写出运算符重载函数(非静态类成员函数)来判断日期类对象d1是否小于(<)日期类对象d2：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
	//运算符重载函数(非静态类成员函数)、
	bool operator<(const Date& d)    //bool operator<(Date* const this,const Date& d) 
	{
		if ((_year < d._year)
			|| (_year == d._year && _month < d._month)
			|| (_year == d._year && _month == d._month && _day < d._day))
		{
			//对象d1小于对象d2(即,对象d1中的日期小于对象d2中的日期)、
			return true;
		}
		else
		{
			//对象d1大于等于对象d2(即,对象d1中的日期大于等于对象d2中的日期)、
			return false;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 14);

	//一、
	if (d1.operator<(d2)) //把自定义类型对象d1的地址传给了隐藏的this指针、
	{
		cout << "<" << endl;
	}

	//二、
	if (d1 < d2)     //if (d1.operator<(d2))       //if (d1.operator<(&d1,d2))
	{
		cout << "<" << endl;
	}

	d1.Print();
	d2.Print();
	return 0;
}

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

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

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

注意：

? ? 1、不能通过连接其他符号(非运算符的符号)来创建新的操作符：比如 operator@，在C语言和C++中不存在运算符@、

? ? 2、重载运算符时要保证该被重载的运算符的操作数，也即重载运算符函数(常使用非静态的类成员函数)的形参中必须至少存在一个(类类型或者枚举类型)(自定义类型)的操作数、

? ? 3、

用于内置类型的各种操作符，在运算符重载时，其含义不能改变，例如：内置的整型? + ，在运算符重载时不能改变其含义、

????4、运算符重载函数作为类成员函数(非静态的类成员函数)时，其形参列表中看起来比实际操作数的数目少1个，这是因为该运算符重载函数是非静态的类成员函数，在其参数列表中的第一个位置上隐藏了一个默认的this指针、

? ? 5、? ?? .*? ??::? ??sizeof? ???:? ??.? ? ? 注意，以上 5 个运算符不能进行运算符重载， * (作为乘法和指针解引用运算符)可以进行运算符重载，但是? .*? 不能进行运算符重载、

5.2、赋值运算符重载

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
	//赋值运算符重载函数(非静态类成员函数)、
	void operator=(const Date& d)    //void operator=(Date* const this,const Date& d) 
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 14);
	Date d3(d1); //调用拷贝构造函数,一个已存在的对象去初始化一个同类型(自定义类型)的要创建的对象、
	d2 = d1;       // d2.operator=(&d2,d1);
	//此处的 = 对于内置类型而言的话,代表的是赋值运算符,由于对象d1和对象d2均是自定义类型,所以这里的 = 代表的就是赋值运算符重载,也叫作复制拷贝,
	//会自动的去调用类体中的赋值运算符重载函数(非静态类成员函数),即一个已经存在的对象去给另外一个也已经存在的同类型(自定义类型)的对象进行赋值操作、
	d1.Print();
	d2.Print();
	return 0;
}

? ? 但是上面的赋值运算符重载函数(非静态类成员函数)的写法是不对，不够全面，因为，我们知道，不管是在C语言中还是在C++中，对于内置类型的赋值运算符 = 而言，是支持连续赋值的，比如，如下代码所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
int main()
{
	int i = 0, j, k;
	j = i; //此时该表达式具有返回值,返回的是左操作数,整型变量j的值,即,不管在C还是C++中,内置类型的赋值操作符=构成的赋值表达式是具有返回值的,因为要支持连续赋值、
	k = j = i;
	printf("%d %d %d\n", i, j, k);
	cout << i << " " << j << " " << k << endl;
	return 0;
}

? ? ?但是我们上面所写的赋值运算符函数(非静态类成员函数)，就目前而言是不支持连续赋值操作的，所以要进行优化，使得其也支持连续赋值操作，如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "->" << _month << "->" << _day << endl;
	}
	//赋值运算符重载函数(非静态类成员函数)、
	//一个正确的运算符重载函数是具有返回值(返回类型)的,具体由被重载的运算符的运算结果所决定的、
	//Date operator=(const Date& d)                   //Date operator<(Date* const this,const Date& d) 
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//	return *this;  //此时要返回的是左操作数,即自定义类型的对象d2,而不是左操作数的地址,其中,隐藏的this指针中存放的是左操作数(自定义类型对象d2)的地址、
	//}

	//在此处,三种返回方式均可以使用,但是,已知在C++中,自定义类型的对象以 传值的形式进行返回时,也会自动调用拷贝构造函数,尽量避免调用拷贝构造函数,所以不使用这种方法,使用传址返回和传引用返回均不会调用拷贝构造函数
	//而传址返回又不如传引用返回,所以应使用传引用返回,虽然上述代码可以完成任务,但是不如使用传引用返回好,当三种方法都可以使用时,就使用 传引用返回,而不要使用 传值返回和传址返回 故再次优化为:
    
    //标准版、
	Date& operator=(const Date& d)       // Date& operator=(Date* const this,const Date& d) 不要写成    const Date& operator=(Date* const this,const Date& d)                                                 
	{                                    //避免在main函数中出现 (d3=d2)=d1,  这样就会报错、
		if (this != &d)  //此处的&是取地址操作,上行代码中的&是引用、
		{ 
			//最好不要写成: if (*this != d) ,此处的*this就是自定义类型的对象d2, 自定义类型的对象d本质上就是自定义类型的对象d1, 那么此处的 ！=  就属于 不等于运算符重载 ,那如果我们没有在类体中
			//实现该 不等于运算符重载函数 的话,系统就会报错,就算在类体中实现了  不等于运算符重载函数  ,那么 if (*this != d) 也是一种函数的调用,效率较低,所以使用第一种方法比较好、 
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;   //此处的if判断语句主要是为了避免在main函数中出现像 d1=d1; 这种某一个已经存在的自定义类型的对象去给自己进行赋值操作,避免做无用功、
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 7, 13);
	Date d2(2022, 7, 14);
	Date d3(d1); //调用拷贝构造函数,一个已存在的对象去初始化一个同类型(自定义类型)的要创建的对象,等价于 Date d3 = d1;
	d2 = d1;     // d2.operator=(&d2,d1); 把左操作数的地址传给了隐藏的this指针、
	//此处的 = 对于内置类型而言的话,代表的是赋值运算符,由于对象d1和对象d2均是自定义类型,所以这里的 = 代表的就是赋值运算符重载,也叫作复制拷贝,
	//会自动的去调用类体中的赋值运算符重载函数(非静态类成员函数),即一个已经存在的对象去给另外一个也已经存在的同类型(自定义类型)的对象进行赋值操作、
	//经过上述操作,此时该 赋值运算符重载 = 就支持了连续赋值、
	//在执行代码 d2=d1; 时,会自动调用类体中的赋值运算符重载函数,然后,该函数返回出来的是自定义类型对象d2,当执行完类体中的赋值运算符重载函数时,会再次返回到该行代码处
	//由于返回出来的是自定义类型的对象d2,在本行代码处,自定义类型的对象d2的生命周期并没有结束,所以类体中的赋值运算符重载函数是可以使用  传值,传引用返回和传址返回 的,但是最好
	//使用 传引用 进行返回、

	//当函数返回时,出了函数作用域,如果返回的对象还未还给系统,则可以使用 传值返回,传引用返回和传址返回 ,但是最好使用 传引用返回 ,如果已经还给系统了,则必须使用传值返回 -> C++入门课件、
	d3 = d2 = d1;
	//d1 = d1;
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}

注意：

? ? 若不在类体中显式的实现赋值运算符重载函数的话，则编译器会在类体中自动生成并调用一个赋值运算符重载函数，对内置类型进行浅拷贝(值拷贝)，对于自定义类型则是通过自动调用其对应的赋值运算符重载函数进行赋值，功能类似于拷贝构造函数、