• 类和对象：运算符重载

     本篇文章来介绍一下C++中的运算符重载，以及与运算符重载有关的三个默认默认成员函数：赋值运算符重载，普通对象取地址与const对象取地址操作符重载，也就是下面图片中6个默认成员函数的后三个，前三个默认成员函数在之前文章中已经讲过类和对象：构造函数，析构函数与拷贝构造函数_一棵西兰花的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_72916130/article/details/132789343?spm=1001.2014.3001.5501，大家不太清楚的可以去看一下。

    本篇文章主要通过一个日期类来进行讲解。我会把完整的日期类放到后面。

    1. class Date
    2. {
    3. public:
    4.     //...
    5. private:
    6. 	int _year;
    7. 	int _month;
    8. 	int _day;
    9. };

    1.什么是运算符重载

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

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

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

    注意：

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

    光看定义是不行的，我们实现以下 > 和 == 的重载

    1. // >运算符重载
    2. //因为>号有两个操作数，因为有一个是隐藏的this指针，所以这里只有一个参数
    3. bool Date::operator>(const Date& d)
    4. {
    5. 	if (_year < d._year)
    6. 	{
    7. 		return false;
    8. 	}
    9. 	else if (_year == d._year && _month < d._month)
    10. 	{
    11. 		return false;
    12. 	}
    13. 	else if (_year == d._year && _month == d._month && _day <= d._day)
    14. 	{
    15. 		return false;
    16. 	}
    17. 	else
    18. 	{
    19. 		return true;
    20. 	}
    21. }
    22.  
    23. // ==运算符重载
    24. bool Date::operator==(const Date& d)
    25. {
    26. 	return _year == d._year && _month == d._month && _day == d._day;
    27. }

    有一个 > 和 == 或< 和 == ，其他比较运算符就可以有这两个推导出来，不用再一个一个写。

    2.赋值运算符重载

    1.赋值运算符重载格式

    • 参数类型：const T&，传递引用可以提高传参效率，加const是为了防止参数被修改
    • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
    • 检测是否自己给自己赋值
    • 返回*this ：要符合连续赋值的含义

    代码：

    1. Date& Date::operator=(const Date& d)//可以不用引用，但没有必要
    2. {
    3. 	if (this != &d)//自己给自己赋值
    4. 	{
    5. 		_year = d._year;
    6. 		_month = d._month;
    7. 		_day = d._day;
    8. 	}
    9. 		
    10. 	return *this;
    11. }

    对于返回*this，因为我们平时的赋值运算符可以实现 类似与 a = b = c = d 的方式，显示调用就是a.operator(b.operator(c.operator(d)))，如果operator=函数没有返回值，就会出现错误。

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

    1. // 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
    2. Date& operator=(Date& left, const Date& right)
    3. {
    4.     if (&left != &right)
    5.     {
    6.         left._year = right._year;
    7.         left._month = right._month;
    8.         left._day = right._day;
    9.     }
    10.     return left;
    11. }
    12.  
    13. // 编译失败：
    14. // error C2801: “operator =”必须是非静态成员

    原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

    3.用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

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

    注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。因为他会将地址也进行简单的值拷贝(浅拷贝)，在进行析构时回释放两次，会导致程序崩溃。

    3.前置++与后置++重载

    前置++与后置++的操作数只有一个，而且只有返回值不同，一个前置++返回自己加一，后置++需要在构造一个Date 来存放没有加一时的结果进行返回。只有返回值不同，没有办法区分两个函数，只好在后置++加入一个占位参数，没有什么用途，只是为了区分前置与后置，编译器也是通过这个方式来识别。

    C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

    代码： 

    1. // 前置++
    2. Date& Date::operator++()
    3. {
    4. 	*this += 1;
    5. 	return *this;
    6. }
    7.  
    8. // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，
    9. //故需在实现时需要先将this保存一份，然后给this+1
    10. // 而temp是临时对象，因此只能以值的方式返回，不能返回引用
    11. // 后置++ 传入的值不用接收
    12. Date Date::operator++(int)
    13. {
    14. 	Date tmp(*this);
    15. 	*this += 1;
    16. 	return tmp;
    17. }

    -- 也一样：        

    1. // 后置--
    2. Date Date::operator--(int)
    3. {
    4. 	Date tmp(*this);
    5. 	*this -= 1;
    6. 	return tmp;
    7. }
    8. // 前置--
    9. Date& Date::operator--()
    10. {
    11. 	*this -= 1;
    12. 	return *this;
    13. }

    4.const成员

    将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数,这里的const需要加在形参列表的后面，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

    我们来看看下面的代码：

    这里类成员函数Print() 没有用const修饰。

    1.     const Date d1(2023, 9, 23);
    2. 	//const修饰的对象调用不了成员函数，因为权限放大
    3. 	d1.Print();//d1.print(&d1) 隐藏的传入this的指针是const Data* 类型

    Print() 没有被const 修饰，函数形参this指针是 普通的 Date* 类型，而被const修饰的对象调用Print()函数，传入的this指针是const Data* 类型 ，会发生权限的放大，权限可以缩小，平移，但是不能放大，会报错。

    请思考下面的几个问题：

    1. const对象可以调用非const成员函数吗？
    2. 非const对象可以调用const成员函数吗？
    3. const成员函数内可以调用其它的非const成员函数吗？
    4. 非const成员函数内可以调用其它的const成员函数吗？

    答案：1，3不可以，权限放大。2，4可以，权限缩小。

    我们可以通过函数重载使不同权限的对象调用不同的函数。如下面代码的Print：

    1. class Date
    2. {
    3. public:
    4.     Date(int year, int month, int day)
    5.     {
    6.         _year = year;
    7.         _month = month;
    8.         _day = day;
    9.     }
    10.     void Print()
    11.     {
    12.         cout << "Print()" << endl;
    13.         cout << "year:" << _year << endl;
    14.         cout << "month:" << _month << endl;
    15.         cout << "day:" << _day << endl << endl;
    16.     }
    17.     void Print() const
    18.     {
    19.         cout << "Print()const" << endl;
    20.         cout << "year:" << _year << endl;
    21.         cout << "month:" << _month << endl;
    22.         cout << "day:" << _day << endl << endl;
    23.     }
    24. private:
    25.     int _year; // 年
    26.     int _month; // 月
    27.     int _day; // 日
    28. };
    29. void Test()
    30. {
    31.     Date d1(2022,1,13);
    32.     d1.Print();
    33.     const Date d2(2022,1,13);
    34.     d2.Print();
    35. }

    当然Print函数用const 修饰是没有什么意义的。我们看下面的取地址及const取地址操作符重载。

    5.取地址及const取地址操作符重载

    这两个默认成员函数一般不用重新定义 ，编译器默认会生成

    1. class Date
    2. {
    3. public :
    4.     //这种方式返回指针的内容可以修改，可读可写
    5.     Date* operator&()
    6.     {
    7.         return this ;
    8.     }
    9.  
    10.     //这种方式返回指针的内容也不能修改，只读
    11.     const Date* operator&()const
    12.     {
    13.         return this ;
    14.     }
    15. private :
    16.     int _year ; // 年
    17.     int _month ; // 月
    18.     int _day ; // 日
    19. };

    这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容，不返回this，返回nullptr等等。

    6. Date 类的实现

    Date.h 

    1. class Date
    2. {
    3.  
    4. public:
    5. 	// 获取某年某月的天数
    6. 	int GetMonthDay(int year, int month);
    7.  
    8. 	//全缺省的构造函数
    9. 	Date(int year = 1900, int month = 1, int day = 1);
    10.  
    11. 	// 赋值运算符重载
    12. 	// d2 = d3 -> d2.operator=(&d2, d3)
    13. 	Date& operator=(const Date& d);
    14.  
    15. 	// 日期+=天数
    16. 	Date& operator+=(int day);
    17. 	// 日期+天数
    18. 	Date operator+(int day);
    19. 	// 日期-天数
    20. 	Date operator-(int day);
    21. 	// 日期-=天数
    22. 	Date& operator-=(int day);
    23.  
    24. 	void Print();
    25.  
    26. 	//下面两个是运算符重载，也构成函数重载
    27. 	// 前置++ 
    28. 	//++d1 -> d1.operator++()
    29. 	Date& operator++();
    30. 	// 后置++
    31. 	//d1++ -> d1.operator++(0)//传一个整形即可，只是用来区分前置++
    32. 	//加了一个int参数，进行占位，跟前置++构成函数重载进行区分
    33. 	//本质后置++调用，编译器进行了特殊处理
    34. 	Date operator++(int);//传入的值不用接收
    35. 	// 后置--
    36. 	Date operator--(int);
    37. 	// 前置--
    38. 	Date& operator--();
    39.  
    40.  
    41. 	// >运算符重载
    42. 	bool operator>(const Date& d);
    43. 	// ==运算符重载
    44. 	bool operator==(const Date& d);
    45. 	// >=运算符重载
    46. 	bool operator >= (const Date& d);
    47. 	// <运算符重载
    48. 	bool operator < (const Date& d);
    49. 	// <=运算符重载
    50. 	bool operator <= (const Date& d);
    51. 	// !=运算符重载
    52. 	bool operator != (const Date& d);
    53.  
    54. 	// 日期-日期 返回天数
    55. 	int operator-(const Date& d);
    56.  
    57. 	const Date* operator&()const;
    58.  
    59. 	Date* operator&();
    60.  
    61. private:
    62. 	int _year;
    63. 	int _month;
    64. 	int _day;
    65. };

    Date.cpp

    1. // 获取某年某月的天数
    2. int Date::GetMonthDay(int year, int month)
    3. {
    4. 	static int MonthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    5. 	if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 400 == 0))
    6. 	{
    7. 		return 29;
    8. 	}
    9. 	return MonthDay[month];
    10. }
    11.  
    12. //全缺省的构造函数
    13. //声明和定义缺省参数的值，不能都给,必须在声明中给，
    14. //因为在编译时头文件中看到的是声明，而声明中没有提供缺省值，会报错。到不了后面的链接，通过函数名修饰规则来找到函数的定义
    15. Date::Date(int year, int month, int day)
    16. {
    17. 	_year = year;
    18. 	_month = month;
    19. 	_day = day;
    20. 	//检查日期日期是否合法
    21. 	if (month < 1 || month>12 || day < 1||_day > GetMonthDay(_year, _month))
    22. 	{
    23. 		cout << "非法日期\n" << endl;
    24. 		exit(-1);
    25.  
    26. 	}
    27. }
    28.  
    29. // 赋值运算符重载
    30. // d2 = d3 -> d2.operator=(&d2, d3)
    31. Date& Date::operator=(const Date& d)//可以不用引用，但没有必要
    32. {
    33. 	if (this != &d)//自己给自己赋值
    34. 	{
    35. 		_year = d._year;
    36. 		_month = d._month;
    37. 		_day = d._day;
    38. 	}
    39. 		
    40. 	return *this;
    41. }
    42.  
    43. // 日期+=天数
    44. Date& Date::operator+=(int day)//0次拷贝 0次赋值
    45. {
    46. 	if (day < 0)
    47. 	{
    48. 		return *this -= (-day);
    49. 	}
    50.  
    51. 	_day += day;
    52. 	while (_day > GetMonthDay(_year, _month))
    53. 	{
    54. 		_day -= GetMonthDay(_year, _month);
    55. 		_month++;
    56. 		while (_month > 12)
    57. 		{
    58. 			_month = 1;
    59. 			_year++;
    60. 		}
    61. 	}
    62. 	return *this;
    63. }
    64. // 日期+天数
    65. Date Date::operator+(int day)//两次拷贝
    66. {
    67. 	if (day < 0)
    68. 	{
    69. 		return *this - (-day);
    70. 	}
    71.  
    72. 	Date ret(*this);
    73.  
    74. 	ret += day;
    75.  
    76. 	return ret;
    77. }
    78.  
    79. // 日期-天数
    80. Date Date::operator-(int day)
    81. {
    82. 	if (day < 0)
    83. 	{
    84. 		return *this + (-day);
    85. 	}
    86.  
    87. 	Date ret = *this;
    88. 	ret -= day;
    89. 	return ret;
    90. }
    91.  
    92. // 日期-=天数
    93. Date& Date::operator-=(int day)
    94. {
    95. 	if (day < 0)
    96. 	{
    97. 		return *this += (-day);
    98. 	}
    99.  
    100. 	_day -= day;
    101. 	while (_day < 1)
    102. 	{
    103. 		_month--;
    104. 		while (_month < 1)
    105. 		{
    106. 			_month = 12;
    107. 			_year--;
    108. 		}
    109. 		_day += GetMonthDay(_year, _month);
    110. 	}
    111. 	return *this;
    112. }
    113.  
    114. //只读函数可以加const,内部不涉及修改成员
    115.  
    116. //void Date::Print(const Data* this)
    117. //void Date::Print() //可以同时存在，因为this指针类型不同，如果只有const版本也可调用，因为权限可以缩小
    118. //{//不过在这里没有意义
    119. //	cout << _year << "/" << _month << "/" << _day << endl;
    120. //}
    121. void Date::Print() const
    122. {
    123. 	cout << _year << "/" << _month << "/" << _day << endl;
    124. }
    125.  
    126. // 前置++
    127. Date& Date::operator++()
    128. {
    129. 	*this += 1;
    130. 	return *this;
    131. }
    132.  
    133. // 后置++
    134. Date Date::operator++(int)
    135. {
    136. 	Date tmp(*this);
    137. 	*this += 1;
    138. 	return tmp;
    139. }
    140. // 后置--
    141. Date Date::operator--(int)
    142. {
    143. 	Date tmp(*this);
    144. 	*this -= 1;
    145. 	return tmp;
    146. }
    147. // 前置--
    148. Date& Date::operator--()
    149. {
    150. 	*this -= 1;
    151. 	return *this;
    152. }
    153.  
    154.  
    155.  
    156. // >运算符重载
    157. bool Date::operator>(const Date& d)
    158. {
    159. 	if (_year < d._year)
    160. 	{
    161. 		return false;
    162. 	}
    163. 	else if (_year == d._year && _month < d._month)
    164. 	{
    165. 		return false;
    166. 	}
    167. 	else if (_year == d._year && _month == d._month && _day <= d._day)
    168. 	{
    169. 		return false;
    170. 	}
    171. 	else
    172. 	{
    173. 		return true;
    174. 	}
    175. }
    176.  
    177. // ==运算符重载
    178. bool Date::operator==(const Date& d)
    179. {
    180. 	return _year == d._year && _month == d._month && _day == d._day;
    181. }
    182.  
    183. // >=运算符重载
    184. bool Date::operator >= (const Date& d)
    185. {
    186. 	return *this > d || *this == d;
    187. }
    188.  
    189. // <运算符重载
    190. bool Date::operator < (const Date& d)
    191. {
    192. 	return !(*this >= d);
    193. }
    194.  
    195. // <=运算符重载
    196. bool Date::operator <= (const Date& d)
    197. {
    198. 	return !(*this > d);
    199. }
    200.  
    201. // !=运算符重载
    202. bool Date::operator != (const Date& d)
    203. {
    204. 	return !(*this == d);
    205. }
    206.  
    207. //跟日期-天数构成函数重载
    208. // 日期-日期 返回天数
    209. int Date::operator-(const Date& d)
    210. {
    211. 	Date max = *this;
    212. 	Date min = d;
    213. 	int flag = 1;
    214. 	if (max < min)
    215. 	{
    216. 		min = *this;
    217. 		max = d;
    218. 		flag = -1;
    219. 	}
    220. 	int count = 0;
    221. 	while (max != min)
    222. 	{
    223. 		--max;
    224. 		count++;
    225. 	}
    226. 	return count * flag;
    227. }
    228.  
    229.  
    230. //日常自动生成的就可以
    231. //不要被取到有效地址
    232. //const Date* Date::operator&()const
    233. //{
    234. //	return nullptr;
    235. //}
    236. const Date* Date::operator&()const
    237. {
    238. 	return this;
    239. }
    240. //这个接口是读写
    241. Date* Date::operator&()//函数重载，一个给const对象用，一个给非const对象用
    242. {
    243. 	return this;
    244. }

    本篇结束！

     

  • 相关阅读:
    Nacos服务注册
    ML之LoR：基于信用卡数据集利用LoR逻辑回归算法实现如何开发通用信用风险评分卡模型之以toad框架全流程讲解
    fallback与fallbackFactory
    P27 含并行连结的网络 GoogLeNet / Inception V3
    Springboot整合dubbo&zookeeper为注册中心
    基于51单片机光照强度检测智能窗帘Proteus仿真
    Redis——Lettuce连接redis集群
    windows注册表引发的bug记录
    【Redis】Redis 的学习教程（十二）之在 Redis使用 lua 脚本
    ＜img＞图片格式类型
  • 原文地址：https://blog.csdn.net/qq_72916130/article/details/133238692