• 【c++】——类和对象(中)——实现完整的日期类(优化）万字详细解疑答惑

    作者:chlorine

    专栏:c++专栏

    赋值运算符重载(+)(+=)(++):实现完整的日期类(上)

    我走的很慢，但我从不后退。

    【学习目标】

    • 日期(- -= --)天数重载运算符
    • 日期-日期 返回天数
    • 对日期类函数进行优化(不符合常理的日期，负数，const成员)
    • c++中重载输入cin和输出cout运算符
    • const成员

    首先我要对上面一篇类和对象(上)进行补充，上一篇主要内容

    • '=' 赋值运算符重载
    • '<'  '='  '>'  '<='  '>='  '!=' 重载运算符
    • '前置++' '后置++’ 重载运算符

    相信大家对于operator的运用以及重载运算符有了一定的了解。本次博客我会继续深化赋值运算符重载的内容，并对各函数进行优化处理。

    目录

    🔑'—' '-='重载运算符

    🔑前置--，后置-- 

     🔑日期-日期=天数

    🔑+=(-=)负数 (优化)

    🔑C++中重载输入cin和输出cout运算符

    🌈重载输入cin运算符>> 

    🌈重载输入cout运算符<<

    🔑不符合常理的日期(优化)

    🔑const成员(优化)

    🌈const对于+=和+ 

    🌈const对于d1d2

    🕶️完整代码

    🚩Date.h

    🚩Date.cpp

    🚩test.cpp

    🔑'—' '-='重载运算符

    我们不只局限于对未来的计算，虽然以前的日子已经一去不复返。如果我们想知道100天是哪一天？该如何操作呢？上面的图片今天是2023年11月18日，一百天前是2023年8月10日，这是该如何计算呢？

    ​

    11月已经被-100了，这里要+上的是10月份的天数。

    ​

    计算过程如图所示。我们可以根据上面思路进行写代码。

    主要思路：先将日-100，然后如果是负数就进入循环 ，月份-1，就可以得到在此基础上的上一个月的天数，然后我们还要考虑一个情况，就是如果月份=0，我们就要追溯到上一年的12月开始。代码如下：

    1. Date &Date::operator-=(int day)
    2. {
    3.     _day-=day;
    4.     while(_day<=0)
    5.    {
    6.        --_month;
    7.       if(_month==0)
    8.       {
    9.         _month=12;
    10.         --_year;
    11.       }    
    12.      _day+=GetMonthDay(_year,_month);
    13.    }
    14.    return *this;
    15. }

     那么-重载运算符和+重载运算符一个道理，不能改变原来的值，就创建一个临时变量tmp，保留d1原来的值，然后返回tmp.

    依旧使用-复用-=的方法.

    1. Date Date::operator-(int day)
    2. {
    3. 	Date tmp(*this);
    4. 	tmp -=day;
    5. 	return tmp;
    6. }

    🔑前置--，后置-- 

    前置--后置--和前置++后置++的用法是一样的

    • 前置--：返回的减之后的值。
    • 后置--：返回的减之前的值，需要用拷贝构造创建 一个临时变量tmp来保存原来的值。并且后置--重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递  。
    1. //前置--返回的是减之后的值
    2. Date& Date::operator--()
    3. {
    4. 	*this -= 1;
    5. 	return *this;
    6. }
    7.  
    8. //后置--返回的是减之前的值
    9. Date Date::operator--(int)
    10. {
    11. 	Date tmp = *this;
    12. 	*this -= 1;
    13. 	return tmp;
    14. }

     🔑日期-日期=天数

    ​

    我想计算一下自己的生日和今天相差多少天？我该如何用代码实现呢？

     第一种思路：

    ​

    • 我们可以与小的日期和大的日期的年份设置成一样的，然后就可以利用 《月和日对齐，利用年判断润平年，闰年一年多少天，平年一年的多少天，相加）
    • 然后算出了2003-10-29~~~2023-10-29相差多少天，然后 《年对齐，利用获得每个月的天数进行相加》

    思路的俩个步骤，比较于直接减方便多了。

    第二种思路：

    • d1-d2   我们先假设d1是小min日期，d2是大max日期，如果我的猜测不对，就将min赋值给d2,max赋值给d1。我们要用flag=1或-1来记录，如果(小-大就得乘以-1)(大-小就得乘以1）
    • 小的数如果一直++是可以与大的数持平的，我们就进行一个循环直到min=max的时候结束，过程中min一直++，用n来记下min一直+的次数，n的值就是天数。

    代码如下：

    1. int Date::operator-(const Date& d)
    2. {
    3. 	Date max = *this;
    4. 	Date min = d;
    5. 	int flag = 1;
    6. 	if (*this<d)
    7. 	{
    8. 		min = *this;
    9. 		max = d;
    10. 		flag = -1;
    11. 	}
    12. 	int n = 0;
    13. 	while (min != max)
    14. 	{
    15. 		++min;
    16. 		++n;
    17. 	}
    18. 	return n*flag;
    19. }

    ​

    计算机的效率是可以完成循环多次的。 

    🔑+=(-=)负数 (优化)

    ​

    图中不管是+还是-都是成立的对于day是正是负都是可以计算的。 

    day+= -100;

     大家有没有想过如果day是负数呢？上面的代码运行的结果是什么呢？

    ​

    这时候我们该如何优化呢？

     d1+= -day 是不是相当于 d1-=day?   那么就可以复用-=重载运算符。

    ​

    这样对嘛，d1+= -100,本来是看以前的日子的，怎么算到2024了？这里我们就要考虑到数学的知识了。 *this是d1 ，d1-=day ,day是-100，那么负负得正， 就成了d1+=day,所以我们需要在day前面加个负号，即d1-= -day。 -day=100,所以 d1-=100 与 d1+=-100 等式成立。

    1. Date& Date::operator+=(int day)
    2. {
    3. 	if (day < 0)
    4. 	{
    5. 		return *this -= day;
    6. 	}
    7. 	_day += day;
    8. 	while (_day > GetMonthDay(_year, _month))
    9. 	{
    10. 		_day -= GetMonthDay(_year, _month);
    11. 		++_month;
    12. 		if (_month >= 13)
    13. 		{
    14. 			++_year;
    15. 			_month = 1;
    16. 		}
    17. 	}
    18. 	return *this;
    19. }

    ​ 

    同理：d1-= -100,看100天后的日期，那么就相当于负负得正，d1+=100,那么用到-=函数里就是  d1+=-day.

    1. Date& Date::operator-=(int day)
    2. {
    3. 	if (day < 0)
    4. 	{
    5. 		return *this += -day;
    6. 	}
    7. 	_day -= day;
    8. 	while (_day <= 0)
    9. 	{
    10. 		--_month;
    11. 		if (_month== 0)
    12. 		{
    13. 			_month = 12;
    14. 			--_year;
    15. 		}
    16. 		_day+= GetMonthDay(_year, _month);
    17. 	}
    18. 	return *this;
    19. }

     ​

    🔑C++中重载输入cin和输出cout运算符

    c++系统实现了一个庞大的类的库，如下图所示。其中ios为基类，其他类都直接或间接派生自ios类.

    ​

    • cin和cout可以直接输入和输出内置类型（如int、double等）和部分标准自定义类型（如string等），原因是标准库已经将所有这些类型的输入和输出重载了，直接使用即可。

    ​

    •  对于我们自定义的类型，如果想直接使用cin、cout来输入输出，需要自己重载>>和<<，否则不能直接使用。

    在C++中，标准库本身已经对左移运算符<<和右移运算符>>分别进行了重载，使其能够用于不同数据的输入输出，但是输入输出的对象只能是 C++内置的数据类型（例如 bool、int、double 等）和标准库所包含的类类型（例如 string、complex、ofstream、ifstream 等）。如果自己定义了一种新的数据类型，需要用输入输出运算符去处理，那么就必须对它们进行重载。本节以Date类为例来演示输入输出运算符的重载。

    1. cout << _year << "-" << _month << "-" << _day << endl;//输出形式
    2. cin>>_year>>_month>>_day; //输入形式

    cout是ostream类的对象，cin是istream类的对象，要想达到这个目标，就必须以全局函数（友元函数）的形式重载<<和>>，否则就要修改标准库中的类，这显然不是我们所期望的。

    🌈重载输入cin运算符>> 

    以全局函数的形式重载>>，

    1. //cin重载
    2. istream& operator>>(istream& _in, Date& d)
    3. {
    4. 	_in >> d._year >> d._month >> d._day;
    5. 	return _in;
    6. }

    注意：运算符重载函数中用到了Date类的private 成员变量，必须在Date类中将该函数声明为友元函数，如下例所示:

    friend istream & operator>> (istream &_in,Date &d);

    🌈重载输入cout运算符<<

    同样地，也可以模仿上面的形式对输入运算符>>进行重载，让它能够输出，请看下面的代码：

    1. //cout重载
    2. ostream& operator<<(ostream& _out, const Date& d)
    3. {
    4. 	_out << d._year << "-" << d._month << "-" << d._day << endl;
    5. 	return _out;
    6. }

    ostream表示输出流，cout是ostream类的对象。由于采用了引用的方式进行参数传递，并且也返回了对象的引用，所以重载后的运算符可以实现连续输出。

    为了能够直接访问Date类的private成员变量，同样需要将该函数声明为complex类的友元函数：
    friend ostream & operator<< (ostream &out, complex &A);

    友元函数的声明：

    ​

    我们有没有观察到

    ​ 

    ​ 

    为什么输入重载里面的参数不加，而输出相反。

    ——输入年月日，如果输入流不能修改，那么就没办法进行输入了，输出在输入之后了，它保留着日期，是不能被修改的。

    ​

    在这之前加coonst也是编译不过的，因为流入和流出的过程取它们其中的值也是需要改变它的状态值，所以输出输入都是不能加const的。 提取完了之后要改变其中内部的状态值的。

    输入输出重载运算符代码如下：

    1. //cin重载
    2. istream& operator>>(istream& _in, Date& d)
    3. {
    4. 	_in >> d._year >> d._month >> d._day;
    5. 	return _in;
    6. }
    7.  
    8. //cout重载
    9. ostream& operator<<(ostream& _out, const Date& d)
    10. {
    11. 	_out << d._year << "-" << d._month << "-" << d._day << endl;
    12. 	return _out;
    13. }

     我们继续优化吧~

    🔑不符合常理的日期(优化)

    这个日期符合常理嘛？显然是不符合的。所有的对象是构造出来的，所以我们再构造的时候加一些检查~

    • 第一种：直接打印出“非法日期”
    • 第二种：直接断言报错（暴力法）

    既然输出流对于不合理的日期进行了检查，那么输入呢？

    输入非法日期之后，是可以直接通过的，那我们就得给流输入进行检查。

    1. //cin重载
    2. istream& operator>>(istream& _in, Date& d)
    3. {
    4. 	//第一种写法
    5. 	_in >> d._year >> d._month >> d._day;
    6. 	if (d._month > 0 && d._month < 13
    7. 		&& d._day>0 && d._day <= d.GetMonthDay(d._year, d._month))
    8. 	{
    9. 	}
    10. 	else
    11. 	{
    12. 		//cout << "非法日期" << endl;
    13. 		assert(false);
    14. 	}
    15. 	return _in;
    16.  
    17. 	//第二种写法：
    18. 		int year, month, day;
    19. 		_in >> year >> month >> day;
    20. 	if (month > 0 && month < 13
    21. 		&& day>0 && day <= d.GetMonthDay(year, month))
    22. 	{
    23. 		d._year = year;
    24. 		d._month = month;
    25. 		d._day = day;
    26. 	}
    27. 	else
    28. 	{
    29. 		//cout << "非法日期" << endl;
    30. 		assert(false);
    31. 	}
    32. }

    一共俩种写法，第二种更灵活。

    🔑const成员(优化)

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

    如何让权限平移或者缩小呢？我们只需要给Date*this改成const Date*this就可以了。

    我们不能动this的类型，因为它是隐含的是无法动的，那么如何将类型改成const使权限不放大呢？所以祖师爷就直接再函数后面加个const就可以了。

    这里加个const 修饰的是*this。const Date* this我们之前就复习了const，这里const修饰的类型是Date，修饰的内容是*this。

    重点：成员函数后面加const以后，普通和const对象都可以调用（权限的平移和权限的缩小）。

    🌈const对于+=和+ 

    那我们所写的所有成员函数都能加个const嘛？

    ——当然不是，要修改的对象成员变量函数不能加。

    比如+=成员函数后面加个const。

    _day===》this->day,const修饰的是this指向的内容，指向的内容都不能修改如何+=呢？——肯定不行。那么+呢？

    +不会改变我自己，我们上面说了成员函数后面加const以后，普通和const对象都可以调用（权限的平移和权限的缩小）。（只要不改变成员变量都可以加）

    所以我们看看还有什么可以加const？

    🌈const对于d1d2?

     

    为什么d1

    这里就考虑到了权限的放大缩小平移问题了，d2是const显然传过去就是权限的放大，当然是不可以的。所以最好的方式就是给这些成员函数都加const。

    结论：只要成员函数内部不修改成员变量，就应该加const，这样const对象和普通对象都可以调用。

    这些成员函数都可以后面加const,因为按上面的结论，就是不修改内部成员变量。

    🕶️完整代码

    🚩Date.h

    1. #pragma once
    2. #include<iostream>
    3. #include<assert.h>
    4. using namespace std;
    5. class Date
    6. {
    7. 	//友元函数的声明
    8. 	friend ostream& operator<<(ostream& _out, const Date& d);
    9. 	friend istream& operator>>(istream& _in, Date& d);
    10. public:
    11.  
    12. 	int GetMonthDay(int year, int month)
    13. 	{
    14. 		int array[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    15. 		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
    16. 		{
    17. 			return 29;
    18. 		}
    19. 		else
    20. 		{
    21. 			return array[month];
    22. 		}
    23. 	}
    24. 	void print() const
    25. 	{
    26. 		cout << _year << "-" << _month << "-" << _day << endl;
    27. 	}
    28. 	Date(int year = 2003, int month = 10, int day = 5);
    29. 	Date& operator=(const Date& d);
    30.  
    31. 	bool operator==(const Date& d)const;
    32. 	bool operator>(const Date& d)const;
    33. 	bool operator>=(const Date& d)const;
    34. 	bool operator<(const Date& d)const;
    35. 	bool operator<=(const Date& d)const;
    36. 	bool operator!=(const Date& d)const;
    37.  
    38. 	//日期+天数
    39. 	Date operator+(int day) const;
    40. 	Date& operator+=(int day);
    41. 	// 日期-天数
    42. 	Date operator-(int day)const;//自己不能改变。但是返回之后的结果
    43. 	Date& operator-=(int day);
    44. 	//前置++
    45. 	Date&operator++();
    46. 	//后置++
    47. 	Date operator++(int);
    48. 	//前置--
    49. 	Date& operator--();
    50. 	//后置--
    51. 	Date operator--(int);
    52. 	//日期-日期
    53. 	int operator-(const Date& d)const;
    54.  
    55. private:
    56. 	int _year;
    57. 	int _month;
    58. 	int _day;
    59. };

    🚩Date.cpp

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. #include"Date.h"
    5.  
    6.  
    7.  
    8. Date::Date(int year, int month, int day)
    9. {
    10. 	if (month>0&&month<13
    11. 	&&day>0&&day<=GetMonthDay(year,month))
    12. 	{
    13. 		_year = year;
    14. 		_month = month;
    15. 		_day = day;
    16. 	}
    17. 	else
    18. 	{
    19. 		//cout << "非法日期" << endl;
    20. 		assert(false);
    21. 	}
    22. }
    23.  
    24. //赋值运算符重载
    25. Date& Date::operator=(const Date& d)
    26. {
    27. 	_year = d._year;
    28. 	_month = d._month;
    29. 	_day = d._day;
    30. 	return (*this);
    31. }
    32.  
    33. bool Date::operator==(const Date& d)const
    34. {
    35. 	return _year == d._year
    36. 		&& _month == d._month
    37. 		&& _day == d._day;
    38. }
    39.  
    40. bool Date::operator>(const Date& d)const
    41. {
    42. 	if (_year > d._year)
    43. 	{
    44. 		return true;
    45. 	}
    46. 	else if (_year == d._year && _month > d._month)
    47. 	{
    48. 		return true;
    49. 	}
    50. 	else if (_year == d._year && _month == d._month && _day >d._day)
    51. 	{
    52. 		return true;
    53. 	}
    54. 	else
    55. 	{
    56. 		return false;
    57. 	}
    58. }
    59.  
    60. bool Date::operator>=(const Date& d)const
    61. {
    62. 	return *this > d || *this == d;
    63. }
    64.  
    65. bool Date::operator<(const Date& d)const
    66. {
    67. 	return !(*this>=d);
    68. }
    69.  
    70. bool Date::operator<=(const Date& d)const
    71. {
    72. 	return !(*this > d);
    73. }
    74.  
    75. bool Date::operator!=(const Date& d)const
    76. {
    77. 	return !(*this == d);
    78. }
    79.  
    80.  
    81.  
    82. +=复用+
    83. //Date& Date::operator+=(int day)
    84. //{
    85. //	*this = *this + day;
    86. //	return *this;
    87. //}
    88. //
    89. //Date Date::operator+(int day)
    90. //{
    91. //	Date tmp(*this);
    92. //	tmp._day += day;
    93. //	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
    94. //	{
    95. //		tmp._day -= GetMonthDay(tmp._year, tmp._month);
    96. //		++tmp._month;
    97. //		if (tmp._month >= 13)
    98. //		{
    99. //			++tmp._year;
    100. //			tmp._month = 1;
    101. //		}
    102. //	}
    103. //	return tmp;
    104. //}
    105.  
    106. //+复用+=
    107. Date Date::operator+(int day)const
    108. {
    109. 	Date tmp(*this);
    110. 	tmp += day;
    111. 	return tmp;
    112. }
    113.  
    114. //d1+=100
    115. Date& Date::operator+=(int day)
    116. {
    117. 	if (day < 0)
    118. 	{
    119. 		return *this -= -day;
    120. 	}
    121. 	_day += day;
    122. 	while (_day > GetMonthDay(_year, _month))
    123. 	{
    124. 		_day -= GetMonthDay(_year, _month);
    125. 		++_month;
    126. 		if (_month >= 13)
    127. 		{
    128. 			++_year;
    129. 			_month = 1;
    130. 		}
    131. 	}
    132. 	return *this;
    133. }
    134.  
    135. //前置++返回的是加之后的值
    136. Date &Date::operator++()
    137. {
    138. 	*this += 1;
    139. 	return *this;
    140. }
    141.  
    142. //后置++返回的是加之前的值
    143. Date Date::operator++(int)
    144. {
    145. 	Date tmp = *this;
    146. 	*this += 1;
    147. 	return tmp;
    148. }
    149.  
    150. //前置--返回的是减之后的值
    151. Date& Date::operator--()
    152. {
    153. 	*this -= 1;
    154. 	return *this;
    155. }
    156.  
    157. //后置--返回的是减之前的值
    158. Date Date::operator--(int)
    159. {
    160. 	Date tmp = *this;
    161. 	*this -= 1;
    162. 	return tmp;
    163. }
    164.  
    165. Date Date::operator-(int day)const
    166. {
    167. 	Date tmp(*this);
    168. 	tmp -=day;
    169. 	return tmp;
    170. }
    171.  
    172. Date& Date::operator-=(int day)
    173. {
    174. 	if (day < 0)
    175. 	{
    176. 		return *this += -day;
    177. 	}
    178. 	_day -= day;
    179. 	while (_day <= 0)
    180. 	{
    181. 		--_month;
    182. 		if (_month== 0)
    183. 		{
    184. 			_month = 12;
    185. 			--_year;
    186. 		}
    187. 		_day+= GetMonthDay(_year, _month);
    188. 	}
    189. 	return *this;
    190. }
    191.  
    192. int Date::operator-(const Date& d)const
    193. {
    194. 	Date max = *this;
    195. 	Date min = d;
    196. 	int flag = 1;
    197. 	if (*this<d)
    198. 	{
    199. 		min = *this;
    200. 		max = d;
    201. 		flag = -1;
    202. 	}
    203. 	int n = 0;
    204. 	while (min != max)
    205. 	{
    206. 		++min;
    207. 		++n;
    208. 	}
    209. 	return n*flag;
    210. }
    211.  
    212. //cin重载
    213. istream& operator>>(istream& _in, Date& d)
    214. {
    215. 	//第一种写法
    216. 	_in >> d._year >> d._month >> d._day;
    217. 	if (d._month > 0 && d._month < 13
    218. 		&& d._day>0 && d._day <= d.GetMonthDay(d._year, d._month))
    219. 	{
    220. 	}
    221. 	else
    222. 	{
    223. 		//cout << "非法日期" << endl;
    224. 		assert(false);
    225. 	}
    226. 	return _in;
    227.  
    228. 	//第二种写法：
    229. 		int year, month, day;
    230. 		_in >> year >> month >> day;
    231. 	if (month > 0 && month < 13
    232. 		&& day>0 && day <= d.GetMonthDay(year, month))
    233. 	{
    234. 		d._year = year;
    235. 		d._month = month;
    236. 		d._day = day;
    237. 	}
    238. 	else
    239. 	{
    240. 		//cout << "非法日期" << endl;
    241. 		assert(false);
    242. 	}
    243. }
    244.  
    245. //cout重载
    246. ostream& operator<<(ostream& _out, const Date& d)
    247. {
    248. 	_out << d._year << "-" << d._month << "-" << d._day << endl;
    249. 	return _out;
    250. }

    🚩test.cpp

    1. #include"Date.h"
    2.  
    3. void TestDate1()
    4. {
    5. 	Date d1(2003, 10, 5);
    6. 	Date d2(2003, 11, 5);
    7. 	int ret=d1 > d2;
    8. 	int ret2 = d1 == d2;
    9. 	int ret3 = d1 < d2;
    10. 	int ret4 = d1 >= d2;
    11. 	cout << ret3 << endl;
    12. }
    13.  
    14. void TestDate2()
    15. {
    16. 	Date d1(2003, 11, 14);
    17. 	Date d2=d1 +100;//运用拷贝构造创建一个临时变量tmp，将*this的值给tmp,*this的值不改变，tmp值改变，
    18. 	//从而导致了d1+day，d1不变，tmp改变。返回d1原来的值。
    19. 	//d1 +=100;
    20. 	//d1 += 100;
    21. 	d2.print();
    22. 	/*d1++;
    23. 	d1.print();
    24. 	++d1;
    25. 	d1.print();*/
    26. }
    27.  
    28. void TestDate3()
    29. {
    30. 	Date d1(2023, 11, 17);
    31. 	Date d2=d1 -100;
    32. 	d2.print();
    33. }
    34.  
    35. void TestDate4()
    36. {
    37. 	Date d1(2023, 11, 17);
    38. 	//d1--;//后置--返回的是之前的值、
    39. 	--d1;//前置--返回的是之后的值
    40. 	d1.print();
    41. }
    42.  
    43. void TestDate5()
    44. {
    45. 	Date d1(2023, 11, 17);
    46. 	Date d2(2003, 10, 29);
    47. 	cout << d1-d2<< endl;
    48. 	cout << d2 - d1<< endl;
    49. }
    50.  
    51. void TestDate6()
    52. {
    53. 	Date d1(2023, 11, 17);
    54. 	d1.print();
    55. 	/*d1 += -100;
    56. 	d1.print();*/
    57. 	d1 -= -100;
    58. 	d1.print();
    59. }
    60.  
    61. void TestDate7()
    62. {
    63. 	//Date d1(2023, 11, 17);
    64. 	//d1 += 100;
    65. 	流插入
    66. 	//cout << d1;
    67. 	//operator<<(cout, d1);
    68. 	Date d1(2023, 11, 17);
    69. 	Date d2(2003, 10, 29);
    70. 	cin >> d1 >> d2;
    71. 	cout << d1 << d2;
    72.  
    73. 	/*Date d4(2023, 13, 1);
    74. 	cout << d4;*/
    75.  
    76. }
    77.  
    78. void TestDate8()
    79. {
    80. 	Date d4(2023,13,1);
    81. 	cin>>d4;
    82. 	cout << d4;
    83. }
    84.  
    85. void TestDate9()
    86. {
    87. 	Date d1(2023, 11, 17);
    88.  
    89. 	const Date d2(2023, 11, 17);
    90. 	d1 < d2;
    91. 	d2 < d1;
    92.  
    93.  
    94. 	//d1 + 100;//d1普通对象
    95. 	//d2 + 100;//const对象
    96. }
    97.  
    98. int main()
    99. {
    100. 	//TestDate1();
    101. 	//TestDate2();
    102. 	//TestDate3();
    103. 	//TestDate4();
    104. 	//TestDate5();
    105. 	//TestDate6();
    106. 	//TestDate7();
    107. 	//TestDate8();
    108. 	TestDate9();
    109. 	return 0;
    110. }

    我走的很慢，但我从不后退。

  • 相关阅读:
    数据结构之：数组
    管理上游数据源配置
    使用Nginx在 Linux 上托管 ASP.NET Core 6.0应用：GitHub Actions自动部署
    python数据分析(3)
    Java中IO、BIO、NIO、AIO分别是什么？
    Error注入攻击
    后端技术盲区大清理：事务还没弄明白的小伙伴赶紧来看一看
    02 认识Verilog HDL
    Shell编程_0Linux之RPM和YUM
    【ONE·C++ || 网络基础（二）】
  • 原文地址：https://blog.csdn.net/m0_74438843/article/details/134479385