5.赋值运算符重载函数
5.1运算符重载函数
在学习赋值运算符重载之前，我们先来了解一下运算符重载：
通过上面的学习，我们已经知道了内置类型和自定义类型的区别，思考这样一个问题：
显而易见，内置类型对象可以直接用各种运算符，内置类型是语言自己定义的，编译直接转换成指令
举个简单的例子，内置类型的int类型2和1，编译器可以轻松知道2>1；内置类型的double类型2.2和1.1,编译器轻松知道2.2>1.1,诸如此类......
那么问题来了，我们通篇写的Data类对象，我这时候需要判断2012年7月7日与2013年7月7日哪个日期更大，编译器能直接判断出2012年7月7日<2013年7月7日吗？显然是不能的！因为自定义类型编译器不支持直接转换成指令。
那么这时候就需要我们自己写一个函数来实现：
写一个大于比较函数：
bool Greater(Data d1, Data 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; } return false; }
再比如我写一个等于比较的函数：
bool Equal(Data d1, Data d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day; }
运行一下：
#include <iostream> using namespace std; class Data { public: Data(int year = 2012, int month = 7, int day = 7) { _year = year; _month = month; _day = day; } Data(const Data& d) { _year = d._year; _month = d._month; _day = d._day; } void Ptint() { cout << _year << "-" << _month << "-" << _day << endl; } //private: int _year; int _month; int _day; }; //布尔类型（bool）用于表示真（true）和假（false）的值。 //它只有两个取值：true 和 false，分别对应 1 和 0 。 bool Greater(Data d1, Data 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; } return false; } bool Equal(Data d1, Data d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day; } int main() { Data d1(2013, 7, 7); Data d2(2012, 7, 7); cout << Greater(d1, d2) << endl; cout << Equal(d1, d2) << endl; return 0; }
说到这里，我们来说一个题外话，关于函数的命名，其实在C语言中我们就遇到过很多了，一个函数命名就如同给自己的孩子取名字一样，比如上面的判断大于和判断相等函数，我能用Greater、Equal，为什么就不能用DaYu、DengYu，或者Compare1、Compare2，又或者func1、func2呢？
这些确实都是可以的呀！我创建的函数，我乐意怎样取名我就怎样取名！
可是话说回来，你的孩子在你口中叫狗蛋儿、在老师口中叫张三，有一天你去开家长会，老师问你是谁的家长，你说你是狗蛋儿的家长，你这样说老师会知道张三就是狗蛋儿，狗蛋儿就是张三吗？
话再说回来，你写的函数叫DaYu、DengYu，而你的同事要用这个函数，你写的DaYu、DengYu，同事能知道这是个什么函数吗？
所以，为了规避这种情况，增强代码的可读性，C++引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
因此上述两个函数就可以写为（更加规范，我们加上const和&）：
//bool Greater(Data d1, Data d2) bool operator>(const Data& d1, const Data& 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; } return false; } //bool Equal(Data d1, Data d2) bool operator == (const Data& d1, const Data& d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day; }
int main() { Data d1(2013, 7, 7); Data d2(2012, 7, 7); /*cout << Greater(d1, d2) << endl; cout << Equal(d1, d2) << endl; */ cout << operator > (d1, d2) << endl; cout << operator == (d1, d2) << endl; return 0; }
以及为了令自定义类型更贴合与内置类型一样让编译器自己计算，直接转为指令：
int main() { Data d1(2013, 7, 7); Data d2(2012, 7, 7); /*cout << Greater(d1, d2) << endl; cout << Equal(d1, d2) << endl; */ /*cout << operator > (d1, d2) << endl; cout << operator == (d1, d2) << endl;*/ bool ret1 = d1 > d2; //d1>d2吗？是为1，否为0； bool ret2 = d1 == d2; //d1=d2吗？是为1，否为0； int a = 3 > 2; //3>2吗？是为1，否为0； int b = 3 == 2; //3=2吗？是为1，否为0； cout << ret1 << endl << ret2 << endl; cout << a << endl << b << endl; return 0; }
仔细观察我们上面写的Data类，可以发现我把private注释掉了，那现在我把注释关掉：
成员变量变私有了该怎么办呢？其实C++常用的解决方法是直接将函数放到类里面，因为类里面可以随便访问private：
class Data { public: Data(int year = 2012, int month = 7, int day = 7) { _year = year; _month = month; _day = day; } Data(const Data& d) { _year = d._year; _month = d._month; _day = d._day; } bool operator == (const Data& d1, const Data& d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day; } void Ptint() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; };
可是这样写发现还是编译不通过：
它说函数参数太多？！我放到类外面参数就不多，怎么放到类里面就多参数了呢？
对！因为存在一个隐含的this指针（详细请看C++入门2——类与对象（1）中的3），所以这时就可以这样修改：
class Data { public: Data(int year = 2012, int month = 7, int day = 7) { _year = year; _month = month; _day = day; } Data(const Data& d) { _year = d._year; _month = d._month; _day = d._day; } bool operator>(const Data& d2) { if (_year > d2._year) { return true; } else if (_year == d2._year && _month > d2._month) { return true; } else if (_year == d2._year && _month == d2._month && _day > d2._day) { return true; } return false; } bool operator == ( const Data& d2) { return _year == d2._year && _month == d2._month && _day == d2._day; } void Ptint() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; };
那么在函数调用时，编译器就会帮我们负重前行：
int main() { Data d1(2013, 7, 7); Data d2(2012, 7, 7); bool ret1 = d1 > d2; //d1.operator>(d2)--->d1.operator>(&d1,d2) bool ret2 = d1 == d2; //d1.operator==(d2)--->d1.operator==(&d1,d2) cout << ret1 << endl << ret2 << endl; return 0; }
所以运算符重载归纳有以下特点：
1. 不能通过连接其他符号来创建新的操作符：比如operator@；
2. 重载操作符必须有一个类类型参数；
3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义；
4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；
5. .* :: sizeof ?: . 以上5个运算符不能重载。
5.2 赋值运算符重载函数
铺了那么多前戏，终于来到我们要学习的赋值运算符重载函数了：
我们知道，拷贝构造就是将一个已经初始化的变量A拷贝到未初始化的变量B中，
那么如果存在两个都已经初始化的变量A、B，我想把A的值拷贝到B，显然就不能再用拷贝构造了，要用到我们就要开始讲的赋值运算符重载：
1. 赋值运算符重载格式：
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义
（详解精华都在代码里）：
#include <iostream> using namespace std; class Data { public: Data(int year = 2012, int month = 7, int day = 7) { _year = year; _month = month; _day = day; } Data(const Data& d) { _year = d._year; _month = d._month; _day = d._day; } //d1=d2;d1传给this，d2传给d //返回值应该是什么类型呢？当然是Data类型；应该返回d1的地址，所以用&引用返回 Data& operator=(const Data& d) { //判断是否为自己给自己赋值，&放到这里不是引用，是取地址： //判断d2的地址是否与d1地址相等 if (this != &d) { _year = d._year; _month = d._month; _day = d._day; } return *this;//返回d1的地址 } void Ptint() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Data d1(2023, 7, 7); Data d2(2022, 8, 8); //拷贝构造：一个已经存在的对象去拷贝初始化另一个对象 Data d3(d2); d1.Ptint(); d2.Ptint(); d3.Ptint(); cout << endl; //赋值运算符重载：两个已经存在的对象拷贝 d1 = d2;//运算自定义类型，就要用到运算符重载operator= d1.Ptint(); d2.Ptint(); d3.Ptint(); }
2. 赋值运算符只能重载成类的成员函数不能重载成全局函数
原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值 运算符重载只能是类的成员函数。
3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
4.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必 须要实现。
这些特性与拷贝构造函数有极大的相似性，这里不再过多赘述。
5.3 前置++和后置++重载
在C语言中，我们已经知道了：前置++，先加后用；后置++，先用后加 这样的基本常识
那么我们学了运算符重载，现在我要自定义类型Data前置++和后置++，要怎么定义和实现呢？
前置++：
前置++为先+1后使用；所以前置++的返回值应该是返回+1之后的结果；
故前置++重载函数的实现为：
// 前置++：返回+1之后的结果 Date& operator++()//返回d1，所以返回值类型当然为Date类型 { _day += 1; return *this;//this指向的对象函数结束后不会销毁，故以&引用方式返回提高效率 }
后置++：
后置++为先使用后+1；所以后置++的返回值应该为+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1；
那么问题来了，前置++和后置++都是一元运算符，实现起来两个函数名字相同，都是operator++，怎么才能区分这两个函数呢？
为了让前置++与后置++形成能正确重载，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
故后置++重载函数的实现为：
Date operator++(int) { Date temp(*this);// 先将this保存一份，然后给this + 1 _day += 1; return temp; // temp是临时对象，出了作用域就会被销毁， //因此只能以值的方式返回，不能返回引用 }
验证：
#include <iostream> using namespace std; class Date { public: Date(int year = 2023, int month = 7, int day = 7) { _year = year; _month = month; _day = day; } // 前置++：返回+1之后的结果 Date& operator++()//返回d1，所以返回值类型当然为Date类型 { _day += 1; return *this;//this指向的对象函数结束后不会销毁，故以&引用方式返回提高效率 } Date operator++(int) { Date temp(*this);// 先将this保存一份，然后给this + 1 _day += 1; return temp; // temp是临时对象，出了作用域就会被销毁， //因此只能以值的方式返回，不能返回引用 } void Print() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2(2022, 7, 7); d1 = ++d2;//前置++，编译器默认调用不带（int）参数的operator++ d1.Print(); d1 = d2++;//后置++，编译器默认调用带（int）参数的operator++ d1.Print(); return 0; }
小知识：在C语言中前置++和后置++二者的效率高低可能并不明显，但是在C++中，一般来说前置++的效率要高于后置++
6.（&）取地址操作符重载函数和const取地址操作符重载函数
6.1 const成员
终于来到类的最后两个默认成员成员函数了，在介绍最后两个默认成员函数之前，我们先来了解一下什么是const成员：
用const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
编译器对const成员的处理：
6.2 取地址及const取地址操作符重载
二者的形式为：
class Date { public: //（&）取地址操作符重载 Date* operator&() { return this; } //const（&）取地址操作符重载 const Date* operator&()const { return this; } private: int _year; // 年 int _month; // 月 int _day; // 日 };
这两个默认成员函数一般不用重新定义 ，编译器默认会生成。
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！所以这里就不再过多介绍这两个默认成员函数。
（本篇完）
