devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C++修行之道】类和对象（五）日期类的实现、const成员、取地址及const和取地址操作符重载

作者：笔触狂放9 | 2024-06-16 23:24:13

赞

踩

【C++修行之道】类和对象（五）日期类的实现、const成员、取地址及const和取地址操作符重载

目录

一、 日期类的实现

Date.h

 1.1 GetMonthDay函数（获取某年某月的天数）

 问：这个函数为什么不和其他的函数一样放在Date.cpp文件中实现呢？

1.2 CheckDate函数（检查日期有效性）、Print函数（打印日期）

1.3 实现日期类的逻辑运算符重载

<运算符的重载

 ==运算符重载

其他运算符重载 

1.4 日期与天数加减操作符重载

1.5 日期相减时的操作符重载

1.6 前置运算符和后置运算符实现的区别

前置运算符的语义是“先操作，再返回”。

后置运算符的语义是“先返回，再操作”。

1.7 输入输出流重载

为什么参数顺序为(ostream& out, const Date& d)?

二、const成员

请思考下面的几个问题：

1. const对象可以调用非const成员函数吗？ 

2. 非const对象可以调用const成员函数吗？

3. const成员函数内可以调用其它的非const成员函数吗？ 

4. 非const成员函数内可以调用其它的const成员函数吗？

三、取地址及const取地址操作符重载 

一、 日期类的实现

Date.h

  1. #define  _CRT_SECURE_NO_WARNINGS 1
  2. #pragma once
  3. #include<iostream>
  4. #include<stdio.h>
  5. #include<string.h>
  6. #include<stdlib.h>
  7. #include<math.h>
  8. #include<time.h>
  9. #include<iostream>
  10. #include<assert.h>
  11.  
  12. using namespace std;
  13.  
  14. class Date {
  15.  
  16. 	// 友元函数声明
  17. 	friend ostream& operator<<(ostream& out, const Date& d);
  18. 	friend istream& operator>>(istream& in, Date& d);
  19.  
  20. public:
  21.  
  22. 	// 全缺省的构造函数
  23. 	Date(int year = 1900, int month = 1, int day = 1);
  24. 	void Print() const;
  25.  
  26. 	// 直接定义在类中，他默认是inline
  27. 	// 频繁调用
  28. 	// 获取某年某月的天数
  29. 	int GetMonthDay(int year, int month)
  30. 	{
  31. 		assert(month > 0 && month < 13);
  32.  
  33. 		static int monthDayArray[13] = { -1,31,28,31,30,31,30,31,30,31,31,30,31 };
  34. 		if ((month == 2) && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
  35. 			return 29;
  36. 		else
  37. 		{
  38. 			return monthDayArray[month];
  39. 		}
  40. 		return monthDayArray[month];
  41. 	}
  42.  
  43. 	bool CheckDate();
  44.  
  45. 	// 不使用引用修改成员的都能加上 const
  46. 	bool operator<(const Date& d) const;
  47. 	bool operator<=(const Date& d) const;
  48. 	bool operator>(const Date& d) const;
  49. 	bool operator>=(const Date& d) const;
  50. 	bool operator==(const Date& d) const;
  51. 	bool operator!=(const Date& d) const;
  52.  
  53. 	// 赋值运算符重载
  54. 	// d2 = d3 -> d2.operator=(&d2, d3)
  55. 	//Date& operator=(const Date& d);
  56.  
  57. 	// d1 += 100
  58. 	// 日期+=天数
  59. 	Date& operator+=(int day);
  60.  
  61. 	// d1 + 100
  62. 	// 日期+天数
  63. 	Date operator+(int day) const;
  64.  
  65.  
  66. 	// d1 -= 100
  67. 	// 日期-=天数
  68. 	Date& operator-=(int day);
  69.  
  70. 	// d1 - 100;
  71. 	// 日期-天数
  72. 	 Date operator-(int day) const;
  73.  
  74. 	// d1 - d2
  75. 	// 日期-日期 返回天数
  76. 	int operator-(const Date& d) const;
  77.  
  78. 	// ++d1
  79. 	Date& operator++();
  80.  
  81. 	// d1++ -> d1.operator(1)
  82. 	// 为了区分,构成了重载,给后置++,强行增加了一个int形参
  83. 	// 这里不需要写形参名,因为接收值是多少不中呀,也不需要调用
  84. 	// 这个参数仅仅是为了前缀和后缀区分而存在的
  85. 	Date operator++(int);
  86.  
  87. 	// --d1
  88. 	Date& operator--();
  89.  
  90. 	// d1--
  91. 	Date operator--(int);
  92.  
  93. 	 流插入
  94. 	//void operator<<(ostream& out);
  95. 	// 不建议, 因为Date* this占据了一个参数位置, 使用d<<cout不符合习惯
  96. 	
  97.  
  98. // private:
  99. 	int _year;
  100. 	int _month;
  101. 	int _day;
  102. };
  103.  
  104. // 重载
  105. ostream& operator<<(ostream & out, const Date & d);
  106. istream& operator>>(istream& in, Date& d);

 1.1 GetMonthDay函数（获取某年某月的天数）

  1. // 获取某年某月的天数 
  2. int GetMonthDay(int year, int month)  
  3. {  
  4.     // 断言：确保传入的月份是有效的  
  5.     assert(month > 0 && month < 13);  
  6.   
  7.     // 存储了每个月通常的天数  
  8.     static int monthDayArray[13] = { -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };  
  9.   
  10.     // 闰年检查：如果月份是2月，并且年份是闰年，则返回29天  
  11.     if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))) {  
  12.         return 29;  
  13.     }  
  14.     // 如果不是2月或年份不是闰年，返回静态数组中存储的对应月份的天数  
  15.     else {  
  16.         return monthDayArray[month];  
  17.     }  
  18. }

 问：这个函数为什么不和其他的函数一样放在Date.cpp文件中实现呢？

  • 内联函数的优化：在类定义中直接实现的成员函数默认为内联函数（inline）。内联函数通常用于减少函数调用的开销，因为它们在编译时会被“内联”到调用它们的代码中。GetMonthDay 函数可能预计会被频繁调用，这对于小型、频繁调用的函数特别有益，可以提高程序的执行效率。

1.2 CheckDate函数（检查日期有效性）、Print函数（打印日期）

  1. bool Date::CheckDate()
  2. {
  3. 	if (_month < 1 || _month > 12 // 检查_month成员变量是否小于1或大于12
  4.     || _day < 1 || _day > GetMonthDay(_year, _month))
  5.     // 检查_day成员变量是否小于1
  6.     // 调用GetMonthDay(_year, _month)获取当前年份和月份对应的天数，并检查_day是否大于这个值 
  7. 	{
  8. 		return false;
  9. 	}
  10. 	else
  11. 	{
  12. 		return true;
  13. 	}
  14. }
  15.  
  16. // Date类的构造函数，用于初始化Date对象
  17. Date::Date(int year, int month, int day)
  18. {
  19. 	_year = year;
  20. 	_month = month;
  21. 	_day = day;
  22.     
  23.     // 调用CheckDate函数检查日期是否合法
  24. 	if (!CheckDate())
  25. 	{
  26. 		cout << "日期非法" << endl;
  27. 	}
  28. }
  29.  
  30. // 打印日期
  31. void Date::Print() const
  32. {
  33. 	cout << _year << "-" << _month << "-" << _day << "\n";
  34. }

1.3 实现日期类的逻辑运算符重载

只需实现两个运算符，就能借助这两个运算符去简易的实现其他运算符。

<运算符的重载

  1. // d1 < d2
  2. bool Date::operator<(const Date& d) const
  3. {
  4. 	if (_year < d._year)
  5. 		return true;
  6. 	else if (_year == d._year)
  7. 	{
  8. 		if (_month < d._month)
  9. 			return true;
  10. 		else if (_month < d._month)
  11. 		{
  12. 			return _day < d._day;
  13. 		}
  14. 	}
  15. 	return false;
  16. }

 ==运算符重载

  1. // d1 == d2
  2. bool Date::operator==(const Date& d) const
  3. {
  4. 	return _year == d._year
  5. 		&& _month == d._month
  6. 		&& _day == d._day;
  7. }

其他运算符重载 

  1. // d1 <= d2
  2. bool Date::operator<=(const Date& d) const
  3. {
  4. 	return *this < d || *this == d;
  5. }
  6.  
  7. bool Date::operator>(const Date& d) const
  8. {
  9. 	return !(*this <= d);
  10. }
  11.  
  12. bool Date::operator>=(const Date& d) const
  13. {
  14. 	return !(*this < d);
  15. }
  16.  
  17. bool Date::operator!=(const Date& d) const
  18. {
  19. 	return !(*this == d);
  20. }

1.4 日期与天数加减操作符重载

  1. // d1 += day
  2. Date& Date::operator+=(int day) 
  3. {
  4. 	_day += day;
  5. 	while (_day > GetMonthDay(_year, _month))
  6. 		// 进位
  7. 	{
  8. 		_day -= GetMonthDay(_year, _month);
  9. 		++_month;
  10. 		if (_month == 13)
  11. 		{
  12. 			++_year;
  13. 			_month = 1;
  14. 		}
  15. 	}
  16. 	return *this;
  17. }
  18.  
  19. // 1970以后
  20. // d1 -= 100
  21. Date& Date::operator-=(int day)
  22. {
  23. 	if (day < 0)
  24. 	{
  25. 		return *this += -day;
  26. 	}
  27.  
  28. 	_day -= day;
  29. 	while (_day <= 0)// 借位
  30. 	{
  31. 		--_month;
  32. 		if (_month == 0)
  33. 		{
  34. 			_month = 12;
  35. 			_year--;
  36. 		}
  37.  
  38. 		//借上一个月的天数
  39. 		_day += GetMonthDay(_year, _month);
  40. 	}
  41.  
  42. 	return *this;
  43. }
  •  += 和 -= 是复合赋值运算符。
  • 功能：复合运算符直接修改调用它们的对象。在Date类的上下文中，+= 运算符将指定的天数加到当前日期上，并直接修改该日期对象。同样，-= 运算符从当前日期中减去指定的天数。
  • 效率：由于不需要创建新对象，复合运算符在性能上可能更高效，特别是在需要频繁更新日期的场景中。

 

  1. Date Date::operator-(int day) const
  2. {
  3. 	Date tmp = *this;
  4. 	tmp -= day;
  5. 	return tmp;
  6. }
  7.  
  8. Date Date::operator+(int day) const
  9. {
  10. 	Date tmp = *this;
  11. 	tmp += day;
  12. 	return tmp;
  13. }
  •  + 和 - 是普通运算符。
  • 功能：普通运算符不直接修改调用它们的对象，而是返回一个新的对象，该对象是原始对象与指定值进行运算后的结果。
  • 效率：由于需要创建新对象，因此在性能上可能略低于复合运算符。

1.5 日期相减时的操作符重载

  1. // d1 - d2
  2. int Date::operator-(const Date& d) const
  3. {
  4. 	Date max = *this;
  5. 	Date min = d;
  6. 	int flag = 1;
  7.  
  8. 	if (*this < d) // 确定最大和最小日期
  9. 	{
  10. 		max = d;
  11. 		min = *this;
  12. 		flag = -1;
  13.         // 即当前对象小于传入的日期，则得到负数天数差
  14. 	}
  15.  
  16. 	int n = 0;
  17. 	while (min != max)// 实现日期的 != 重载
  18. 	{
  19. 		++min;
  20. 		++n;
  21. 	}
  22.  
  23. 	return n * flag;
  24. }

  • 当前对象的日期早于传入的日期对象。此时，将max设置为d，min设置为*this，并将flag设置为-1。这意味着最终的天数差将是负数。 
  •  在while循环体内，每次迭代都会对min进行自增操作（通过++运算符重载实现），同时计数器n也自增。这个过程会一直持续到min和max相等，即两个日期相同为止。

1.6 前置运算符和后置运算符实现的区别

  1. // ++d1
  2. Date& Date::operator++()
  3. {
  4. 	*this += 1;
  5. 	return *this;
  6. }
  7.  
  8. // d1++ -> d1.operator(1)
  9. // 为了区分,构成了重载,给后置++,强行增加了一个int形参
  10. // 这里不需要写形参名,因为接收值是多少不重要,也不需要调用
  11. // 这个参数仅仅是为了前缀和后缀区分而存在的
  12. Date Date::operator++(int)
  13. {
  14. 	Date tmp(*this);
  15. 	*this += 1;
  16. 	return tmp;
  17. }
  18.  
  19. // --d1
  20. Date& Date::operator--()
  21. {
  22. 	*this -= 1;
  23. 	return *this;
  24. }
  25.  
  26. // d1--
  27. Date Date::operator--(int)
  28. {
  29. 	Date tmp = *this;
  30. 	*this -= 1;
  31. 	return tmp;
  32. }

为了区分，构成了重载,给后置++，强行增加了一个int形参。

Date Date::operator++(int)

这里不需要写形参名，因为接收值是多少不重要，也不需要调用。
这个参数仅仅是为了前缀和后缀区分而存在的。

前置运算符的语义是“先操作，再返回”。

  • 语义上：前置运算符的语义是先对对象进行递作，然后返回操作后的对象。这里的关键是“操作后的对象”。
  • 效率：返回引用避免了不必要的创建和返回对象的拷贝。在C++中，对象的复制可能是一个昂贵的操作。
  • 链式操作：通过返回引用，可以支持链式操作。例如，可以这样写代码：--date = anotherDate; 
  • 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率

后置运算符的语义是“先返回，再操作”。

  • 语义上：后置运算符的语义是先返回操作后的对象，然后对对象进行递作。后置运算符的关键在于返回操作前的状态。
  • 安全性：返回拷贝还避免了潜在的外部修改，此时得到的是一个独立的值，而不是对原始数据的直接引用。原始数据没有影响。
  • 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
    C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。
  • 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1。
  • 而temp是临时对象，因此只能以值的方式返回，不能返回引用

1.7 输入输出流重载

  1. // 友元函数声明，声明后可访问私有成员变量
  2. friend ostream& operator<<(ostream& out, const Date& d);
  3. friend istream& operator>>(istream& in, Date& d);
  4.  
  5. // 重载输出流操作符<<，用于将Date对象以特定格式输出到输出流中
  6. ostream& operator<<(ostream& out, const Date& d)
  7. {
  8.     // 向输出流中输出Date对象的年份、月份和日期，并添加中文字符和换行符进行格式化
  9. 	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
  10.     // 返回输出流的引用，以便支持链式调用
  11. 	return out;
  12. }
  13.  
  14. // 重载输入流操作符>>，用于从输入流中读取数据并设置到Date对象中
  15. istream& operator>>(istream& in, Date& d)
  16. {
  17. 	cout << "请依次输入年月日:>";
  18. 	in >> d._year >> d._month >> d._day;
  19.     
  20.     // 调用Date对象的CheckDate()方法检查输入的日期是否合法 
  21. 	if (!d.CheckDate())
  22. 	{
  23. 		cout << "日期非法" << endl;
  24. 	}
  25.     
  26.     // 返回输入流的引用，以便支持链式调用
  27. 	return in;
  28. }

为什么参数顺序为(ostream& out, const Date& d)?

  • 标准的流插入运算符 << 是左结合的，也就是说左侧应该是流对象（如 cout），右侧是我们想要输出的对象（如 Date）。改变参数顺序后，调用方式也必须相应改变即（<< cout），这与常规用法不符。

标准库中的 operator<< 已经定义好了左侧是 ostream&，右侧是要输出的对象。改变参数顺序后，编译器不会再将其识别为流插入运算符，导致无法正常使用链式调用等特性。

将 operator<< 的参数顺序反过来会导致函数不能正常作为流插入运算符使用，破坏标准库的调用方式和使用习惯。

二、const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
我们来看看下面的代码

  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. }

请思考下面的几个问题：

1. const对象可以调用非const成员函数吗？ 

const对象不能调用非const成员函数。

  • 当你将一个对象声明为const时，实际上是在承诺不会修改这个对象的状态。因此，只能对这个对象调用const成员函数，因为这些函数承诺不会修改对象的状态。

2. 非const对象可以调用const成员函数吗？

非const对象可以调用const成员函数。

  • const成员函数的主要目的是确保函数不会修改对象的状态。因此，对于非const对象（即可以修改的对象）来说，调用const成员函数是安全的，因为即使对象本身可以被修改，const成员函数也承诺不会修改它。

3. const成员函数内可以调用其它的非const成员函数吗？ 

不可以。在const成员函数中，不能直接调用同一个类的非const成员函数。原因是const成员函数承诺不会修改对象的状态，而如果它调用了非const成员函数，就会违背这个承诺，因为非const成员函数可能会修改对象。

然而，有一种情况可以间接调用非const成员函数，那就是如果你将对象的const性质通过const_cast去除，然后调用非const成员函数。但这种做法是不推荐的，因为它破坏了const的正确性和对象的常量性质，可能导致未定义行为或程序错误。通常来说，应该尽量避免这种做法。

总结来说，const成员函数内不能直接调用非const成员函数，以保持const成员函数的承诺不修改对象状态。

4. 非const成员函数内可以调用其它的const成员函数吗？

是的，非const成员函数内部可以调用const成员函数。

const成员函数的主要特点是它不会修改调用它的对象的状态。因此，从逻辑上讲，在可以修改对象状态的非const成员函数中调用一个不会修改对象状态的const成员函数是安全的。

三、取地址及const取地址操作符重载 

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

  1. class A
  2. {
  3. public:
  4. 	// 我们不实现，编译器会自己实现，我们实现了编译器就不会自己实现了
  5. 	// 一般不需要我们自己实现
  6. 	// 除非不想让别人取到这个类型对象的真实地址
  7. 	A* operator&()
  8. 	{
  9. 		cout << "A* operator&()" << endl;
  10.  
  11. 		return nullptr;
  12. 	}
  13.  
  14. 	const A* operator&() const
  15. 	{
  16. 		cout << "const A* operator&() const" << endl;
  17.  
  18. 		return (const A*)0xffffffff;
  19. 	}
  20. private:
  21. 	int _a1 = 1;
  22. 	int _a2 = 2;
  23. 	int _a3 = 3;
  24. };
  25.  
  26. int main()
  27. {
  28. 	A aa1;
  29. 	const A aa2;
  30.  
  31. 	cout << &aa1 << endl;
  32. 	cout << &aa2 << endl;
  33.  
  34. 	return 0;
  35. }

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

今天就先到这了！！！

看到这里了还不给博主扣个：
⛳️ 点赞☀️收藏 ⭐️ 关注！

你们的点赞就是博主更新最大的动力！
有问题可以评论或者私信呢秒回哦。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/728719
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号