【C++杂货铺】运算符重载
目录
- 前言
- 一、运算符重载
- 二、赋值运算符重载
- 三、完善日期类
-
- 3.1 重载关系运算符
- 3.2 重载`+`、`+=`
- 3.3 重载`-`、`-=`
- 3.4 重载`++`、`--`
- 3.5 重载`<<`、`>>`
- 四、const成员
- 五、取地址及const取地址操作符重载
前言
本文将以日期类为基础，去探寻运算符重载的特性与使用方法，下面先给出日期类的基础定义：
class Date
{
public:
Date::Date(int year, int month, int day)
{
if (month > 0 && month <= 12
&& day > 0 && day <= GetDay(year, month))
{
_year = year;
_month = month;
_day = day;
}
else
{
cout << "非法日期" << endl;
assert(false);
}
}
private:
int _year;//年
int _month;//月
int _day;//日
};
备注：拷贝构造函数和析构函数，均可以不写，因为当前日期类的三个成员变量都是内置类型，没有动态申请空间，使用浅拷贝就可以。
一、运算符重载
如何比较两个日期的大小？
int main()
{
Date d1(2023, 7, 21);
Date d2(2023, 6, 21);
return 0;
}
现如今，定义了两个日期类的对象d1和d2，该如何比较这两个对现象的大小呢？首先想到的是，写一个函数来比较他俩的大小，向下面这样：
//以小于比较为例
bool Less(const Date& x, const Date& y)
{
if (x._year > y._year)
{
return false;
}
else if (x._year == y._year && x._month > y._month)
{
return false;
}
else if (x._year == y._year && x._month == y._month && x._day > y._day)
{
return false;
}
else
{
return true;
}
}
存在的问题：首先这个函数是写在类外面的，意味着，日期类的成员变量如果是private私有的话，在类外面就无法访问，所以在这个函数里面是访问不到对象的年、月、日这三个成员变量，即x._year等都是非法的，要想实现该函数的功能，日期类的成员变量必须是public公有。
其次，在比较两个日期类对象大小的时候，需要写成Less(d1, d2)，这和我们平时直接用<符号比较大小，比起来不够直观。
为什么日期类不能直接使用<
因为日期类是我们自己定义的，属于一种自定义类型，它的大小比较方式，只有定义它的人知道，而像int、double等内置类型，是祖师爷创造C++语言时就定好的，祖师爷当然知道该如何比较两个内置类型变量的大小，所以提前帮我们设置好了，我们可以直接用<去比较两个内置类型变量的大小，而至于祖师爷是怎么设置的，这里先埋一个伏笔。
运算符重载
为了解决上面Less函数存在的问题，C++引入了运算符重载，它可以让我们直接使用<来比较两个日期类的大小。
运算符重载是具有特殊函数名的函数，也具有返回值类型，函数名字、参数列表、返回值类型都和普通函数类似。
- 函数名字：关键字
operator后面接需要重载的运算符符号。 - 函数原型：返回值类型 operator操作符（参数列表）
bool operator<(const Date& x, const Date& y)
{
if (x._year > y._year)
{
return false;
}
else if (x._year == y._year && x._month > y._month)
{
return false;
}
else if (x._year == y._year && x._month == y._month && x._day > y._day)
{
return false;
}
else
{
return true;
}
}
上面就是对<运算符的一个重载，它的两个形参是Data类型的引用，此时两个日期类对象就可以直接用<来比较大小啦，d1 < d2本质上就是调用运算符重载函数，但是由于上面的运算符重载函数还是写在类外面，所以当日期类的成员变量是private私有的时候，该运算符重载函数还是用不了。
//下面两条语句是等价的本质都是调用运算符重载函数
d1 < d2;
operator<(d1, d2);//d1 < d2的本质
将运算符重载函数写成成员函数
为了解决上面的私有成员变量在类外面无法访问的问题，可以把运算符重载函数写成类的成员函数或者友元，这样就能访问到私有的成员变量，但是友元一般不建议使用，因为友元会破坏封装。
bool operator<(const Date& d)
{
if (_year < d._year)
{
return true;
}
else if (_year == d._year && _month < d._month)
{
return true;
}
else if (_year == d._year && _month < d._month && _day < d._day)
{
return true;
}
else
{
return false;
}
}
上面就是把<运算符重载成类的成员函数，此时参数只有一个，因为<是一个双目运算符，类的非静态成员函数有一个隐藏的形参this指针，所以形参就只需要一个。
//它们俩是等价的
d1 < d2;
d1.operator<(d2);//d1 < d2的本质
小Tips：一个双目运算符如果重载成类的成员函数，会把它的左操作数传给第一个形参，把右操作数传给第二个形参。以上面为例，this指针接收的是d1的地址，d接收的是d2。
注意事项：
- 不能通过连接其他符号来创建新的运算符：比如
operator@。 - 重载操作符必须有一个类类型参数。
- 用于内置类型的运算符，其含义不能改变，例如：内置的
+，不能改变其含义。 - 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的
this。 .*、::、sizeof、? :、.这五个运算符不能重载。
二、赋值运算符重载
区分赋值运算符重载和拷贝构造
Date d1(2020, 5, 21);
Date d2(2023, 6, 21);
d1 = d2;//需要调用赋值运算符重载
Date d3 = d1;//这里是调用拷贝构造函数
//Date d3(d1);//和上一行等价调用拷贝构造
要区分赋值运算符重载和拷贝构造，前者是针对两个已存在的对象，将一个对象的值，赋值给另一个，而后者是用一个已存在的对象去初始化创建一个新对象。
赋值运算符重载格式：
- 参数类型：
const T&（T是类型），传引用返回可以提高效率。 - 返回值类型：
T&，返回引用可以提高效率，有返回值目的是为了支持连续赋值。 - 检测是否自己给自己赋值。
- 返回
*this：要符合连续赋值的含义。
Date& operator=(const Data& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;//出了作用域*this还在，所以可以用引用返回
}
只能是类的成员函数
上面的<运算符，最开始我们是在类外面把它重载成全局的，后来为了保证类的封装性，才把它重载成类的成员函数，而赋值运算符天生只能重载成类的成员函数，因为赋值运算符重载属于类的默认成员函数，我们不写，编译器会自动生成，所以，如果我们把赋值运算符重载写在类外面，就会和编译器生成的默认赋值运算符重载发生冲突。
编译器生成的干了些什么工作？
用户没有显式实现时，编译器生成的默认赋值运算符重载，对内置类型的成员变量是以值的方式逐字节进行拷贝（浅拷贝），对自定义类型的成员变量，调用其对应类的赋值运算符重载。
三、完善日期类
有了上面的基础，接下来完善一下日期类，重载其他的运算符。
3.1 重载关系运算符
关系运算符有<、>、==、<=、>=、!=，由于它们之间存在的逻辑关系，可以通过复用来实现，即：要想知道a是否大于b，可以通过判断a是否小于等于b来实现。因此，我们只要写一个<和==的比较逻辑，其他的直接复用即可。
重载<
bool operator<(const Date& d)
{
if (_year < d._year)
{
return true;
}
else if (_year == d._year && _month < d._month)
{
return true;
}
else if (_year == d._year && _month < d._month && _day < d._day)
{
return true;
}
else
{
return false;
}
}
重载==
bool Date::operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
重载<=
bool Date::operator<=(const Date& d)
{
return *this < d || *this == d;
}
重载>
bool Date::operator>(const Date& d)
{
return !(*this <= d);
}
重载>=
bool Date::operator>=(const Date& d)
{
return !(*this < d);
}
重载!=
bool Date::operator!=(const Date& d)
{
return !(*this == d);
}
3.2 重载+、+=
有时我们需要知道几天之后的日期，比如我想知道100天后的日期，此时就需要用当前的日期加上100，但是一个日期类型和一个整型可以相加嘛？答案是肯定的，可以通过重载+来实现。运算符重载只规定必须有一个类类型参数，并没有说重载双目操作符必须要两个类型一样的参数。
获取某月的天数
日期加天数，要实现日期的进位，即：当当前日期是这个月的最后一天时，再加一天月份就要进一，当当前的日期是12月31日时，再加一天年份就要进一，因此可以先实现一个函数，用来获取当前月份的天数，在每加一天后，判断月份是否需要进位。
int GetDay(int year, int month)//获取某一月的天数
{
static int arr[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)))
{
return 29;
}
return arr[month];
}
除了2月，每个月的天数都是固定的，因此可以设置一个数组来存放每个月的天数，并且以月份作为下标，对应存储该月的天数，这种方法类似于哈希映射。这里还有两个小细节，第一个：把数组设置成静态，因为这个函数会重复调用多次，把数组设置成静态，它第一次创建之后，一直到程序结束都还在，可以避免函数调用时重复的创建数组。第二点：把month == 2放在前面判断，因为只有当2月的时候才需要判断是否是闰年，如果不是2月就不用判断是不是闰年。
重载+
Date Date::operator+(int x)
{
if(x < 0)//天数为负的时候
{
return *this - (-x);//复用-
}
/Date tmp = *this;
//Date tmp(*this);//和上面等价，都是调用拷贝构造函数
tmp._day = _day + x;
while (tmp._day > GetDay(tmp._year, tmp._month))
{
tmp._day = tmp._day - GetDay(tmp._year, tmp._month);
tmp._month++;
if (tmp._month == 13)
{
tmp._year++;
tmp._month = 1;
}
}
return tmp;//
}
注意：要计算a+b的结果，a是不能改变的，因此一个日期加天数，不能改变原本的日期，也就是不能修改this指针指向的内容，所以我们要先利用拷贝构造函数创建一个和*this一模一样的对象，对应上面代码中的tmp，在该对象的基础上去加天数。出了作用域tmp对象会销毁，所以不能传引用返回。
重载+=
+=和+很像，区别在于+=是在原来是日期上进行修改，即直接对this指针指向的日期做修改，所以我们对上面的代码稍作修改就可以得到+=。
Date& Date::operator+=(int x)
{
if (x < 0)//当天数为负
{
return *this -= -x;//复用-=
}
_day += x;
while (_day > GetDay(_year, _month))
{
_day = _day - GetDay(_year, _month);
_month++;
if (_month == 13)
{
_year++;
_month = 1;
}
}
return *this;
}
小Tips：加一个负的天数，就是算多少天以前的日期，所以，当天数为负的时候，可以复用下面的-=。
+和+=之间的复用
可以发现，+和+=的实现方法十分相似，那是否可以考虑复用呢？答案是肯定的，他俩其中的一方都可以去复用另一方。
+去复用+=：
Date Date::operator+(int x)
{
/Date tmp = *this;
//Date tmp(*this);//和上面等价，都是调用拷贝构造函数
tmp += x;
return tmp;//
}
+=去复用+：
Date& Date::operator+=(int x)
{
*this = *this + x;//这里是调用赋值运算符重载
return *this;
}
注意：上面的两种复用，只能存在一个，不能同时都去复用，同时存在会出现你调用我，我调用你的死穴。
既然只能存在一个，那到底该让谁去复用呢？答案是：让+去复用+=。因为，+=原本的实现过程中并没有调用拷贝构造去创建新的对象，而+原本的实现过程中，会去调用拷贝构造函数创建新的对象，并且是以值传递的方式返回的，期间又会调用拷贝构造。如果让+=去复用+，原本还无需调用拷贝构造，复用后反而还要调用拷贝构造创建新对象，造成了没必要的浪费。
3.3 重载-、-=
有时我们也需要知道，多少天以前的日期，此时就需要重载-，它的两个操作数分别是日期和天数，其次，我们有时还想知道两个日期之间隔了多少天，这也需要重载-，但此时的两个操作数都是日期。两个-重载构成了函数重载。
重载日期-天数
有了上面的经验，我们可以先重载-=，再让-去复用-=即可，日期减天数，就是要实现日期的借位。
Date Date::operator-(int x)
{
Date tmp(*this);
return tmp -= x;//复用-=
}
重载-=
Date& operator-=(int x)
{
if (x < 0)//天数天数小于0
{
return *this += -x;//复用+=
}
_day -= x;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
_month = 12;
_year--;
}
_day += GetDay(_year, _month);
}
return *this;
}
重载日期-日期
日期-日期，它的形参是一个日期对象，计算的结果是两个日期之间的天数，所以返回值是int，要像知道两个日期之间相隔的天数，可以设置一个计数器，让小日期一直加到大日期，就可以知道两个日期之间相隔的天数。
int operator-(const Date& d)
{
Date max = *this;//存放大日期
Date min = d;//存放小日期
int flag = 1;
if (*this < d)
{
max = d;
min = *this;
flag = -1;
}
int n = 0;
while (max != min)
{
--max;
++n;
}
return n * flag;
}
3.4 重载++、--
++、--操作符，无论前置还是后置，都是一元运算符，为了让前置和后置形成正确的重载，C++规定：后置重载的时候多增加一个int类型的参数，但是当使用后置，调用运算符重载函数时该参数不用传递，编译器自动传递。
重载前置++
//前置++,返回++之后的值
Date& Date::operator++()
{
return *this += 1;//直接复用+=
}
重载后置++
//后置++,返回加之前的值
Date Date::operator++(int)//编译器会把有int的视为后置++
{
Date tmp(*this);
*this += 1;//复用+=
return tmp;
}
重载前置--
Date& operator--()
{
return *this -= 1;//复用了-=
}
重载后置--
Date operator--(int)
{
Date tmp(*this);
*this -= 1;//复用了-=
return tmp;
}
对比前置和后置可以发现，后置会调用两次拷贝构造函数，一次在创建tmp的时候，另一次在函数返回的时候。而前置则没有调用拷贝构造，所以前置的效率相比后置会高那么一点。
3.5 重载<<、>>
同理，对于自定义类型，编译器仍然不知道如何打印，所以要想通过<<去直接打印日期类对象，需要我们对<<运算符进行重载。
重识cout、cin
我们在使用C++进行输入输出的时候，会用到cin和cout，它们俩本质上都是对象，cin是istream类实例化的对象，cout是ostream类实例化的对象。
内置类型可以直接使用<<、>>，本质上是因为库中进行运算符重载。而<<、>>不用像C语言的printf和scanf那样，int对应%d，float对应%f，是因为运算符重载本质上是函数，对这些不同的内置类型，分别进行了封装，在运算符重载的基础上又实现了函数重载，所以<<、>>支持自动识别类型。
<<为什么不能重载成成员函数
要实现对日期类的<<，要对<<进行重载。但是<<和其他的运算符有所不同，上面重载的所有运算符，为了保证类的封装性，都重载成了类的成员函数，但是<<不行，因为我们平时的使用习惯是cout << d1，前面说过，对于一个双目运算符的重载，它的左操作数会传递给运算符重载函数的第一个形参，右操作数会传递给运算符重载函数的第二个形参，也就是说cout会传递给第一个形参，日期类对象d2会传递给第二个形参，如果运算符重载函数是类的成员函数的话，那么它的第一个形参是默认的this指针，该指针是日期类类型的指针，和cout的类型不匹配，当然也有解决办法，那就是输出一个日期类对象的时候，写成d1 << cout，此时就相当于d1.operator(cout)，会把d1的地址传给this指针，形参再用一个ostream类型的对象来接收cout即可，但是这样的使用方式，显然是不合常理的。
将<<重载成全局函数
正确的做法是，把<<重载成全局函数，此时函数形参就没有默认的this指针，我们可以根据需要来设置形参的顺序，第一个形参用ostream类对象来接收cout，第二个形参用Date日期类对象来接收d1。
//重载成全局的
ostream& operator<< (ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return out;
}
注意：形参out不能加const修饰，因为我们就是要往out里面写东西，加了const意味着out不能修改。其次为了实现连续的输出，返回值是ostream类型的对象out，因为此时出了作用域out还在，所以可以用引用返回。
因为该运算符重载函数写在全局，默认情况下，在该函数内部是无法访问到日期类的私有成员变量，为了解决这个问题，可以把该运算符重载函数设置成友元函数，或者在类里面写私有成员变量的Get方法（Java常用）。
friend ostream& operator<< (ostream& out, Date& d);
友元函数只需要配合上friend关键字，在日期类里面加上一条声明即可，此时在该函数体就可以使用对象中的私有成员变量。该声明不受类中访问限定符的限制。
重载>>
同理，>>也应该重载成全局的。
istream& operator>> (istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
注意：两个形参in和d都不能用const修饰，前者是因为in本质上是一个对象，在进行流插入的时候，会改变对象里面的一些状态值，而后者是因为，我们就是希望通过流插入往d里面写入数据，所以也不能加const修饰。
小Tips：C++中的流插入和流提取可以完美的支持自定义类型的输入输出，而C语言的scanf和printf只能支持内置类型，这就是C++相较于C语言的一个优势。
四、const成员
将const修饰的成员函数称为const成员函数，const修饰类的成员函数，实际上修饰的是该成员函数隐含的*this，表明该成员函数中不能修改调用该函数的对象中的任何成员。这样一来，不仅普通对象可以调用该成员函数（权限的缩小），const对象也能调用该成员函数（权限的平移）。经过const修饰的成员函数，它的形参this的类型就是：const T* const this。
bool Date::operator<(const Date& d) const//用const修饰
{
if (_year < d._year)
{
return true;
}
else if (_year == d._year && _month < d._month)
{
return true;
}
else if (_year == d._year && _month < d._month && _day < d._day)
{
return true;
}
else
{
return false;
}
}
对于所有的关系运算符重载函数，都应该加const修饰，因为它们不会改变对象本身。
总结：
并不是所有的成员函数都要加const修饰，要修改对象成员变量的函数，是不能加const修饰的，例如：重载的+=、-=等，而成员函数中如果没有修改对象的成员变量，可以考虑加上const修饰，这样不仅普通对象可以调用该成员函数（权限的缩小），const对象也能调用该成员函数（权限的平移）。
五、取地址及const取地址操作符重载
Date* operator&()
{
cout << "Date* operator&()" << endl;
return this;
}
const Date* operator&() const
{
cout << "const Date* operator&() const" << endl;
return this;
}
int main()
{
Date d1(2023, 7, 22);
const Date d2(2023, 7, 22);
cout << &d1 << endl;
cout << "--------" << endl;
cout << &d2 << endl;
return 0;
}
这俩取地址运算符重载函数，又构成函数重载，因为它们的默认形参this指针的类型不同，一个用const修饰了，另一个没有。const对象会去调用const修饰的取地址运算符重载函数。
小Tips：这两个&重载，属于类的默认成员函数，我们不写编译器会自动生成，所以这两个运算符重载一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。
结语：
今天的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，您的支持就是春人前进的动力！