• 【C++深入浅出】日期类的实现

    目录

    一. 前言 

    二. 日期类的框架

    三. 日期类的实现

    3.1 构造函数

    3.2 析构函数

    3.3 赋值运算符重载

    3.4 关系运算符重载

    3.5 日期 +/- 天数

    3.6 自增与自减运算符重载

    3.7 日期 - 日期

    四. 完整代码 

    一. 前言 

            通过前面两期类和对象的学习，我们已经对C++的类有了一定的了解。本期我们的目标是实现一个完整的日期类，通过实现日期类的构造函数、运算符重载等等内容，加深对前面知识的理解。

            实现了日期类之后，我们就相当于自己实现了一个网上的日期计算器，如下所示

             上面的两项功能，都是通过我们接下来要进行的运算符重载实现的。

    二. 日期类的框架

            以下是我们本期实现的日期类的基本框架

    1. class Date
    2. {
    3. public:
    4. 	// 全缺省的构造函数
    5. 	Date(int year = 2023, int month = 1, int day = 1);
    6.  
    7. 	// 拷贝构造函数
    8. 	Date(const Date& d);
    9.  
    10. 	// 赋值运算符重载
    11. 	Date& operator=(const Date& d);
    12.  
    13. 	// 析构函数
    14. 	~Date() {};
    15.  
    16. 	// +、=等算数运算符重载
    17. 	Date& operator+=(int day); //日期+=天数
    18. 	Date operator+(int day); //日期+天数
    19. 	Date& operator-=(int day); //日期-=天数
    20. 	Date operator-(int day); //日期-天数
    21.  
    22. 	// 日期-日期 返回天数,即日期差
    23. 	int operator-(const Date& d);
    24.  
    25. 	// 自增、自减运算符重载
    26. 	Date& operator++(); //前置++
    27. 	Date operator++(int); //后置++
    28. 	Date operator--(int); //后置--
    29. 	Date& operator--(); //前置--
    30.  
    31. 	// >、<、==等关系运算符重载
    32. 	bool operator>(const Date& d); 
    33. 	bool operator==(const Date& d); 
    34. 	bool operator >= (const Date& d);
    35. 	bool operator < (const Date& d);
    36. 	bool operator <= (const Date& d);
    37. 	bool operator != (const Date& d);
    38.  
    39. 	//打印数据
    40. 	void Print();
    41.  
    42. private:
    43. 	int _year; //年
    44. 	int _month; //月
    45. 	int _day; //日
    46. };

    三. 日期类的实现

    3.1 构造函数

            构造函数的目的是初始化类对象，这里我们只需要实现两种构造函数即可。一种是全缺省的构造函数，使用全缺省的构造函数可以让类对象构造时传参更加灵活；而另一种则是拷贝构造函数。

            全缺省的构造函数

            很简单，我们只需要判断传入的参数是否符合生活中日期的规则，如果符合则正常进行初始化，反之则程序退出。规则大致如下

    日期规则

    1、月份必须在1月到12月之间。例如0月和13月是非法的

    2、日份必须在当前月的天数范围内。例如1月32日，4月31日是非法的

            由于每个月的天数不同，尤其是2月，还有闰年平年之分，故我们可以先写个函数用来获取当前月的天数。这个函数不仅可以用在日份的判断，在之后也会经常用到。

    1. // 获取某年某月的天数
    2. int GetMonthDay(int year, int month)
    3. {
    4.     //用一个数组表示平年每月的天数，下标表示月份
    5. 	int MouthDayArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    6. 	if (month == 2 &&(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) //判断闰年
    7. 	{
    8. 		MouthDayArray[2]++; //是闰年，2月份天数+1
    9. 	}
    10. 	return MouthDayArray[month]; //返回当前月天数
    11. }

            有了上面的函数， 再根据之前的规则，我们很容易就可以写出构造函数

    1. // 全缺省的构造函数
    2. Date(int year = 2023, int month = 1, int day = 1)
    3. {
    4. 	if ( month < 1 || month > 12 || day < 1 || day > GetMonthDay(year, month))
    5. 	{
    6. 		cout << "日期非法" << endl;
    7. 		exit(-1);
    8. 	}
    9. 	_year = year;
    10. 	_month = month;
    11. 	_day = day;
    12. }

            拷贝构造函数

            拷贝构造函数就更简单了，拷贝构造函数是用已存在的对象初始化新对象，故不需要考虑日期是否合法，直接拷贝即可，如下：

    1. // 拷贝构造函数, d2(d1)
    2. Date(const Date& d) //加const避免d被意外修改，使用引用传递是为了提高效率
    3. {
    4. 	_year = d._year;
    5. 	_month = d._month;
    6. 	_day = d._day;
    7. }

    3.2 析构函数

            由于日期类不涉及动态内存管理，因此使用编译器自动生成的析构函数即可，不需要显式进行实现。 

    3.3 赋值运算符重载

            同理，由于日期类不涉及动态内存管理，因此只要进行普通的浅拷贝即可，编译器默认生成的赋值运算符重载函数即可完成要求。

    1. //赋值运算符重载，不需要显式进行实现，这里使用编译器默认生成的即可
    2. Date& operator=(const Date& d)
    3. {
    4. 	_year = d._year;
    5. 	_month = d._month;
    6. 	_day = d._day;
    7. 	return *this; //返回当前对象的引用为了实现链式访问
    8. }

    3.4 关系运算符重载

            关系运算符有>、<、>=、<=、==以及!=，我们先来实现">"运算符。

            我们要如何判断一个日期大于另一个日期呢？很简单，先比较年，年相等则比较月，月相等则比较日，直到比出结果。代码如下：

    1. // >运算符重载
    2. bool operator>(const Date& d)
    3. {
    4. 	if (_year > d._year) //比较年
    5. 	{
    6. 		return true; 
    7. 	}
    8. 	else if (_year == d._year && _month > d._month) //年相等比较月
    9. 	{
    10. 		return true;
    11. 	}
    12. 	else if (_year == d._year && _month == d._month && _day > d._day) //年月都相等比较日
    13. 	{
    14. 		return true;
    15. 	}
    16. 	else //前面的条件都不符合，说明日期比较小，返回false
    17. 	{
    18. 		return false;
    19. 	}
    20. }

            接下来是"=="运算符，这就简单啦，看看年月日是否都相等即可 

    1. // ==运算符重载
    2. bool operator==(const Date& d)
    3. {
    4.     // 逻辑与，下面的条件都符合才返回true，否则为false
    5. 	return (_year == d._year) && (_month == d._month) && (_day == d._day);
    6. }

            然后是"<"运算符，我知道我知道，把上面">"运算符的逻辑都反过来再敲一遍就好啦 

            这种方法固然可以，但未免会显得过于冗余。实际上，我们已经实现了">"运算符和"=="运算符重载，那"<"不就是既不大于也不等于嘛，我们复用一下之前的重载函数即可，如下

    1. // <运算符重载
    2. bool operator<(const Date& d)
    3. {
    4.     //*this表示当前对象
    5. 	return !((*this == d) || (*this > d)); //逻辑非之后表示既不大于也不等于
    6. }

            通过复用的方法，剩下的"<="、">="和"!="我们也可以很轻松的写出来，如下：

    1. // >=运算符重载
    2. bool operator>=(const Date& d)
    3. {
    4. 	return !(*this < d); //复用<运算符
    5. }
    6.  
    7. // <=运算符重载
    8. bool operator<=(const Date& d)
    9. {
    10. 	return !(*this > d); //复用>运算符
    11. }
    12.  
    13. // !=运算符重载
    14. bool operator!=(const Date& d)
    15. {
    16. 	return !(*this == d); //复用==运算符
    17. }

    小贴士：实现类中成员函数时，并不意味着每个都要将其逻辑完整地写出，有些函数之间可以相互复用，简化代码。例如上面我们只需实现">"号和"=="号的重载函数，其余的函数直接复用即可。

    3.5 日期 +/- 天数

            接下来我们来实现日期计算器的第一个功能：推算几天后的日期。通过重载"+/-"号运算符我们可以实现日期 +/- 指定天数

             日期 + 指定天数

             首先，我们要知道，日期的进位规则和我们的十进制不一样。每个月的天数都不同，当超过本月的天数，月份都要进1，并且每过12个月年份都要进1。故我们需要用到之前实现的获取本月天数的函数，用来判断是否需要进位。

            例如，求在12月3号的基础上100天后是几月几号？计算过程如下

     

            下面给出示例代码（初版）： 

    1. // 日期+=天数(初版)
    2. Date& operator+=(int day)
    3. {
    4. 	_day += day; //先将天数全部加到_day上
    5.     
    6.     //下面开始进行进位
    7. 	while (_day > GetMonthDay(_year, _month)) //当_day大于本月的天数说明还需要进行进位，继续
    8. 	{
    9. 		//月进位
    10. 		_day -= GetMonthDay(_year, _month); //减去当前月的天数
    11. 		++_month; //来到下一月
    12.  
    13. 		//月进位后判断年是否需要进位
    14. 		if (_month == 13)
    15. 		{
    16. 			++_year;
    17. 			_month = 1; //进位后月份来到了1月
    18. 		}
    19. 	}
    20. 	return *this;
    21. }

    不过需要注意的是：上面的代码我们对日期进行了修改，返回的是修改后的对象，故实现的不是"+"号的运算符重载，而是"+="运算符的重载。

            那如果我们要实现"+"号呢？很简单，拷贝一份原对象，然后对拷贝后的对象复用"+="运算符重载即可，这样就不会对原对象进行修改。代码如下：

    1. // 日期+天数
    2. Date operator+(int day)
    3. {
    4. 	Date tmp(*this); //拷贝构造一个临时变量
    5. 	tmp += day; //复用+=运算符，此时tmp就是加上day后的日期，但原对象并没有改变
    6. 	return tmp; //以值的形式返回
    7. }

            日期 - 指定天数

            实现了推算几天后的日期，我们再来实现推算几天前的日期。同样的，我们先实现"-="运算符的重载，然后"-"号运算符进行复用即可。

            日期+天数是进行进位，那么日期-天数就是进行借位、退位，二者互为逆过程。有一点需要注意的是，退位借的是上一个月的天数，故我们需要先让月先减再让天数增加。动图如下：

            下面是是示例代码（初版）： 

    1. // 日期-=天数(初版)
    2. Date& operator-=(int day)
    3. {
    4. 	_day -= day; //先全部减到_day上
    5. 	while (_day <= 0) //_day小于0说明需要借位，进行循环
    6. 	{
    7. 		//月先借位
    8. 		--_month;
    9. 			
    10. 		//月借位后判断年是否需要借位
    11. 		if (_month == 0)
    12. 		{
    13. 			--_year; //年借位
    14. 			_month = 12; //月变为上一年12月
    15. 		}
    16. 		_day += GetMonthDay(_year, _month); //将借到的天数进行累加
    17. 	}
    18. 	return *this;
    19. }

             实现了日期-=天数，那么日期-天数直接复用即可

    1. // 日期-天数
    2. Date operator-(int day)
    3. {
    4. 	Date tmp(*this); //拷贝构造
    5. 	tmp -= day; //复用-=运算符
    6. 	return tmp;
    7. }

            细心的小伙伴可能发现了，上面我们写的"+="和"-="运算符重载都是初版，是有哪里要改进吗？没错，其实上面的代码在特殊情况下有出错的风险，即用户传入的天数如果是个负数，那么最终得到的答案可能就不是我们想要的。但是我们再来看看网上的日期计算器

            没错，网上的日期计算器对负数有着特殊处理，输入负数时则是向前计算，即减去相应的天数。故我们可以参考进行实现：

    1. // 日期+=天数(终版)
    2. Date& operator+=(int day)
    3. {
    4. 	if (day < 0) //先判断day的正负
    5. 	{
    6. 		*this -= (-day); //为负数则复用-=运算符
    7. 		return *this; //直接返回
    8. 	} 
    9. 	_day += day; //先将天数全部加到_day上
    10.     
    11.     //下面开始进行进位
    12. 	while (_day > GetMonthDay(_year, _month)) //当_day大于本月的天数说明还需要进行进位，继续
    13. 	{
    14. 		//月进位
    15. 		_day -= GetMonthDay(_year, _month); //减去当前月的天数
    16. 		++_month; //来到下一月
    17.  
    18. 		//月进位后判断年是否需要进位
    19. 		if (_month == 13)
    20. 		{
    21. 			++_year;
    22. 			_month = 1; //进位后月份来到了1月
    23. 		}
    24. 	}
    25. 	return *this;
    26. }

    对于"+="运算，我们通过复用"-="实现对负数的特殊处理。而对于"-="运算，我们可以复用"+="实现对负数的特殊处理，这里就不再展开了。

    3.6 自增与自减运算符重载

            在上面实现日期+=天数和日期-=天数的基础上，我们通过复用可以很轻松地实现自增和自减运算符重载，代码如下：

    1. // 前置++
    2. Date& operator++()
    3. {
    4.     *this += 1; //先+1
    5. 	return *this; //再返回，返回+1后的结果
    6. }
    7.  
    8. // 后置++
    9. Date operator++(int) //int用于占位，表示后置++
    10. {
    11. 	Date tmp(*this); //拷贝一份
    12. 	*this += 1; //然后+1
    13. 	return tmp; //返回+1前的结果
    14. }
    15.  
    16. // 前置--
    17. Date& operator--()
    18. {
    19.     *this -= 1; //先-1
    20. 	return *this; //再返回，返回-1后的结果
    21. }
    22.  
    23. // 后置--
    24. Date operator--(int) //int用于占位，表示后置--
    25. {
    26. 	Date tmp(*this); //拷贝一份
    27. 	*this -= 1; //然后-1
    28. 	return tmp; //返回-1前的结果
    29. }
    30.

    3.7 日期 - 日期

            我们知道，日期+日期是没有意义的，但日期-日期却是很有价值的，可以用来获取两个日期之间间隔的天数。故我们最后还要来实现"-"号运算符的另外一个重载版本，用于进行日期-日期的运算。

            由于日期类的运算规则较为复杂，涉及到每年的天数不同，每月的天数不同，以及平闰年之分，如果采用正常的年-年，月-月的方法，想想都头大

            故我们另辟稀径，我们可以先找出较小的那个日期，然后让较小的日期不断+1，用一个变量count来统计+1的次数，直到较小的日期和较大的日期相等时，count的值不就是我们要求的差值嘛代码如下：

    1. // 日期-日期 返回天数
    2. //法1：年-年，月-月，日-日，太过复杂
    3. //法2：找出较小的那个，一直累加直到等于大的那个，累加的次数就是之间的天数
    4. int operator-(const Date& d)
    5. {
    6.     //找出较小的那个日期，这里先假设*this较小
    7. 	Date min = *this;
    8. 	Date max = d;
    9. 	int flag = -1; //用于表示最后相减结果的符号
    10. 	if (min > max) //假设不成立，互换
    11. 	{
    12. 		min = d;
    13. 		max = *this;
    14. 		flag = 1;
    15. 	}
    16.  
    17.     //小的进行累加，直到二者相等
    18. 	int ret = 0; //统计min累加的次数
    19. 	while (max > min)
    20. 	{
    21. 		min++;
    22.         ret++; 
    23. 	}
    24. 	return ret*flag; //最终累加的次数即为日期差
    25. }

    四. 完整代码 

            最后给出本期日期类的完整代码，需要的读者自取

    1. class Date
    2. {
    3. public:
    4. 	// 获取某年某月的天数
    5. 	int GetMonthDay(int year, int month)
    6. 	{
    7. 		//用一个数组表示平年每月的天数，下标表示月份
    8. 		int MouthDayArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    9. 		if (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) //判断闰年
    10. 		{
    11. 			MouthDayArray[2]++; //是闰年，2月份天数+1
    12. 		}
    13. 		return MouthDayArray[month]; //返回当前月天数
    14. 	}
    15.  
    16. 	// 全缺省的构造函数
    17. 	Date(int year = 2023, int month = 1, int day = 1)
    18. 	{
    19. 		if (month < 1 || month > 12 || day < 1 || day > GetMonthDay(year, month))
    20. 		{
    21. 			cout << "日期非法" << endl;
    22. 			exit(-1);
    23. 		}
    24. 		_year = year;
    25. 		_month = month;
    26. 		_day = day;
    27. 	}
    28.  
    29. 	// 拷贝构造函数, d2(d1)
    30. 	Date(const Date& d) //加const避免d被意外修改，使用引用传递是为了提高效率
    31. 	{
    32. 		_year = d._year;
    33. 		_month = d._month;
    34. 		_day = d._day;
    35. 	}
    36.  
    37. 	//赋值运算符重载，不需要显式进行实现，使用编译器默认生成的即可
    38. 	Date& operator=(const Date& d)
    39. 	{
    40. 		_year = d._year;
    41. 		_month = d._month;
    42. 		_day = d._day;
    43. 		return *this; //返回当前对象的引用为了实现链式访问
    44. 	}
    45.  
    46. 	// 析构函数
    47. 	~Date() {};
    48.  
    49. 	// 日期+=天数
    50. 	Date& operator+=(int day)
    51. 	{
    52. 		if (day < 0)
    53. 		{
    54. 			*this -= (-day);
    55. 			return *this;
    56. 		}
    57. 		_day += day;
    58. 		while (_day > GetMonthDay(_year, _month))
    59. 		{
    60. 			//月进位
    61. 			_day -= GetMonthDay(_year, _month);
    62. 			++_month;
    63.  
    64. 			//年进位
    65. 			if (_month == 13)
    66. 			{
    67. 				++_year;
    68. 				_month = 1;
    69. 			}
    70. 		}
    71. 		return *this;
    72. 	}
    73.  
    74. 	// 日期+天数
    75. 	Date operator+(int day)
    76. 	{
    77. 		if (day < 0)
    78. 		{
    79. 			return *this - (-day) ;
    80. 		}
    81. 		Date tmp(*this); //拷贝构造
    82. 		tmp += day; //复用+=运算符
    83. 		return tmp;
    84. 	}
    85.  
    86. 	// 日期-=天数
    87. 	Date& operator-=(int day)
    88. 	{
    89. 		if (day < 0)
    90. 		{
    91. 			*this += (-day);
    92. 			return *this;
    93. 		}
    94. 		_day -= day;
    95. 		while (_day <= 0)
    96. 		{
    97. 			//月让位
    98. 			--_month;
    99. 			
    100. 			//年让位
    101. 			if (_month == 0)
    102. 			{
    103. 				--_year;
    104. 				_month = 12;
    105. 			}
    106. 			_day += GetMonthDay(_year, _month);
    107. 		}
    108. 		return *this;
    109. 	}
    110.  
    111. 	// 前置++
    112. 	Date& operator++()
    113. 	{
    114. 		*this += 1; //先+1
    115. 		return *this; //再返回，返回+1后的结果
    116. 	}
    117.  
    118. 	// 后置++
    119. 	Date operator++(int) //int用于占位，表示后置++
    120. 	{
    121. 		Date tmp(*this); //拷贝一份
    122. 		*this += 1; //然后+1
    123. 		return tmp; //返回+1前的结果
    124. 	}
    125.  
    126. 	// 前置--
    127. 	Date& operator--()
    128. 	{
    129. 		*this -= 1; //先-1
    130. 		return *this; //再返回，返回-1后的结果
    131. 	}
    132.  
    133. 	// 后置--
    134. 	Date operator--(int) //int用于占位，表示后置--
    135. 	{
    136. 		Date tmp(*this); //拷贝一份
    137. 		*this -= 1; //然后-1
    138. 		return tmp; //返回-1前的结果
    139. 	}
    140.  
    141. 	// >运算符重载
    142. 	bool operator>(const Date& d)
    143. 	{
    144. 		if (_year > d._year) //比较年
    145. 		{
    146. 			return true;
    147. 		}
    148. 		else if (_year == d._year && _month > d._month) //年相等比较月
    149. 		{
    150. 			return true;
    151. 		}
    152. 		else if (_year == d._year && _month == d._month && _day > d._day) //年月都相等比较日
    153. 		{
    154. 			return true;
    155. 		}
    156. 		else //前面的条件都不符合，说明日期比较小，返回false
    157. 		{
    158. 			return false;
    159. 		}
    160. 	}
    161.  
    162. 	// ==运算符重载
    163. 	bool operator==(const Date& d)
    164. 	{
    165. 		return (_year == d._year) && (_month == d._month) && (_day == d._day);
    166. 	}
    167.  
    168. 	// <运算符重载
    169. 	bool operator<(const Date& d)
    170. 	{
    171. 		//*this表示当前对象
    172. 		return !((*this == d) || (*this > d)); //逻辑非之后表示既不大于也不等于
    173. 	}
    174.  
    175. 	// >=运算符重载
    176. 	bool operator >= (const Date& d)
    177. 	{
    178. 		return !(*this < d); //复用<运算符
    179. 	}
    180.  
    181. 	// <=运算符重载
    182. 	bool operator <= (const Date & d)
    183. 	{
    184. 		return !(*this > d); //复用>运算符
    185. 	}
    186.  
    187. 	// !=运算符重载
    188. 	bool operator != (const Date& d)
    189. 	{
    190. 		return !(*this == d); //复用==运算符
    191. 	}
    192.  
    193. 	// 日期-日期 返回天数
    194. 	//法1：年-年，月-月，日-日，太过复杂
    195. 	//法2：找出较小的那个，一直累加直到等于大的那个，累加的次数就是之间的天数
    196. 	int operator-(const Date& d)
    197. 	{
    198. 		//找出较小的那个日期，这里先假设*this较小
    199. 		Date min = *this;
    200. 		Date max = d;
    201. 		int flag = -1; //用于表示最后相减结果的符号
    202. 		if (min > max) //假设不成立，互换
    203. 		{
    204. 			min = d;
    205. 			max = *this;
    206. 			flag = 1;
    207. 		}
    208.  
    209. 		//小的进行累加，直到二者相等
    210. 		int ret = 0; //统计min累加的次数
    211. 		while (max > min)
    212. 		{
    213. 			min++;
    214. 			ret++;
    215. 		}
    216. 		return ret * flag; //最终累加的次数即为日期差
    217. 	}
    218.  
    219. 	//打印数据
    220. 	void Print()
    221. 	{
    222. 		cout << _year << "年" << _month << "月" << _day << "日" << endl;
    223. 	}
    224. private:
    225. 	int _year;
    226. 	int _month;
    227. 	int _day;
    228. };

    以上，就是本期的全部内容啦🌸

    制作不易，能否点个赞再走呢🙏

  • 相关阅读:
    隐函数求导例题及解析
    简单介绍Map中的getOrDefault
    漫画sql数据分析
    如何实现redis的高可用？
    训练人工智能机器人的软实力
    Protobuf编码规则
    带你Java入门（Java系列1）
    Linux make/Makefile详解
    Windows使用ssh远程连接(虚拟机）Linux（Ubuntu）的方法
    循序渐进了解如何使用JSR303进接口数据校验
  • 原文地址：https://blog.csdn.net/m0_69909682/article/details/132537165