• 【C++】：日期类实现

    朋友们、伙计们，我们又见面了，本期来给大家解读一下有关C++的基础知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

    C 语 言 专 栏：C语言：从入门到精通

    数据结构专栏：数据结构

    个  人  主  页 ：stackY、

    C + + 专 栏   ：C++

    Linux 专 栏  ：Linux

    目录

    前言：

    1. 基本构造

    2. 基础运算符重载

    3. 进阶运算符重载

    3.1 日期+天数

    3.2 日期-天数

    3.3 日期+、-天数的优化版本

    3.4 前置++、后置++、前置--、后置--

    3.5 日期与日期相差天数

    4. 流提取、流插入运算符重载

    4.1 流插入

    完整的优化代码：

    4.2 流提取

    5. 完整代码

    前言：

    承接上篇的类和对象本期我们来实现一下日期类，顺便再来回顾一下构造函数和运算符的重载，关于基本的运算符重载就不做过多的解释，之前没提到过的会在这里重点解释。

    1. 基本构造

    日期类的实现我们采用分文件来进行实现：

    在头文件 Date.h中实现日期类的基本框架

    在源文件 Date.cpp中实现框架逻辑

    在源文件 Test.cpp中实现测试逻辑

    日期类的基本创建只需要写出构造函数和打印函数即可，因为日期类中没有资源的创建与释放，所以编译器自动生成的析构函数和拷贝构造以及&运算符重载足够使用。

    头文件 ：Date.h

    1. //日期类
    2. class Date
    3. {
    4. public:
    5. 	//不涉及内部数据的修改的函数可以加上const修饰
    6. 	 
    7. 	//拷贝构造函数（全缺省）
    8. 	Date(int year = 1949, int month = 10, int day = 1);
    9.  
    10. 	//打印函数
    11. 	void Print() const;
    12. private:
    13. 	int _year;  //年
    14. 	int _month; //月
    15. 	int _day;   //日
    16. };

    源文件：Date.cpp

    1. //拷贝构造函数（全缺省）
    2. Date::Date(int year, int month, int day)
    3. {
    4. 	_year = year;
    5. 	_month = month;
    6. 	_day = day;
    7. }
    8.  
    9. //打印函数
    10. void Date::Print() const
    11. {
    12. 	cout << _year << "/" << _month << "/" << _day << endl;
    13. }

    2. 基础运算符重载

    基础运算符的重载包括==、!=、<、<=、>、>=，这几个运算符重载比较简单，在这里就不做解析。

    头文件：Date.h

    1. //日期类
    2. class Date
    3. {
    4. public:
    5. 	//不涉及内部数据的修改的函数可以加上const修饰
    6. 	 
    7. 	//拷贝构造函数（全缺省）
    8. 	Date(int year = 1949, int month = 10, int day = 1);
    9.  
    10. 	//打印函数
    11. 	void Print() const;
    12.  
    13. 	//==运算符重载
    14. 	bool operator==(const Date& d) const;
    15. 	//!=运算符重载
    16. 	bool operator!=(const Date& d) const;
    17. 	//<运算符重载
    18. 	bool operator<(const Date& d) const;
    19. 	//<=运算符重载
    20. 	bool operator<=(const Date& d) const;
    21. 	//>运算符重载
    22. 	bool operator>(const Date& d) const;
    23. 	//>=运算符重载
    24. 	bool operator>=(const Date& d) const;
    25.  
    26. private:
    27. 	int _year;  //年
    28. 	int _month; //月
    29. 	int _day;   //日
    30. };

    源文件 ：Date.cpp

    1. //==运算符重载
    2. bool Date::operator==(const Date& d) const
    3. {
    4. 	return _year == d._year
    5. 		&& _month == d._month
    6. 		&& _day == d._day;
    7. }
    8. //!=运算符重载
    9. bool Date::operator!=(const Date& d) const
    10. {
    11. 	return !(*this == d);
    12. }
    13. //<运算符重载
    14. bool Date::operator<(const Date& d) const
    15. {
    16. 	if (_year < d._year)
    17. 	{
    18. 		return true;
    19. 	}
    20. 	else if (_year == d._year && _month < d._month)
    21. 	{
    22. 		return true;
    23. 	}
    24. 	else if (_year == d._year && _month == d._month && _day < d._day)
    25. 	{
    26. 		return true;
    27. 	}
    28. 	else
    29. 	{
    30. 		return false;
    31. 	}
    32. }
    33. //<=运算符重载
    34. bool Date::operator<=(const Date& d) const
    35. {
    36. 	return *this == d || *this < d;
    37. }
    38. //>运算符重载
    39. bool Date::operator>(const Date& d) const
    40. {
    41. 	return !(*this <= d);
    42. }
    43. //>=运算符重载
    44. bool Date::operator>=(const Date& d) const
    45. {
    46. 	return !(*this < d);
    47. }

    3. 进阶运算符重载

    基础的运算符重载只能满足一部分的需求，还需要对日期的加减。

    3.1 日期+天数

    一个日期+一个天数即可得到另外的一个日期，这里就存在一个天数满了进位月份，月份满了进位年份，那么就需要一个另外的函数来获取某一月的天数。

    获取天数函数：

    1. //获取某一个月的天数
    2. int Date::GetMonthDay(int year, int month) const
    3. {
    4. 	const static int MonthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    5. 	if (month == 2
    6. 		&& (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    7. 	{
    8. 		return 29;
    9. 	}
    10. 	return MonthArray[month];
    11. }

     首先判断是否为闰年，然后根据月份返回相对应的天数。

    日期+天数代码：

    头文件：Date.h

    1. //日期类
    2. class Date
    3. {
    4. public:
    5.     //拷贝构造函数（全缺省）
    6. 	Date(int year = 1949, int month = 10, int day = 1);
    7. 	//获取某一个月的天数
    8. 	int GetMonthDay(int year, int month) const;
    9. 	//+=运算符重载
    10. 	Date& operator+=(int day);
    11. 	//+运算符重载
    12. 	Date operator+(int day) const;
    13. private:
    14. 	int _year;  //年
    15. 	int _month; //月
    16. 	int _day;   //日
    17. };

    源文件：Date.cpp

    1.  
    2. //获取某一个月的天数
    3. int Date::GetMonthDay(int year, int month) const
    4. {
    5. 	const static int MonthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    6. 	if (month == 2
    7. 		&& (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    8. 	{
    9. 		return 29;
    10. 	}
    11. 	return MonthArray[month];
    12. }
    13. //+=运算符重载
    14. Date& Date::operator+=(int day)
    15. {
    16. 	_day += day;
    17. 	//判断天数的合理性
    18. 	while (_day > GetMonthDay(_year, _month))
    19. 	{
    20. 		_day -= GetMonthDay(_year, _month);
    21. 		++_month;  //天满了进位月份
    22. 		if (_month == 13)
    23. 		{
    24. 			++_year;   //月份满了进位年份
    25. 			_month = 1;
    26. 		}
    27. 	}
    28. 	return *this;
    29. }
    30. //+运算符重载
    31. Date Date::operator+(int day) const
    32. {
    33. 	//构造一个新的Date
    34. 	Date tmp(*this);
    35. 	tmp += day;
    36. 	return tmp;
    37. }

    3.2 日期-天数

    头文件：Date.h

    1. //日期类
    2. class Date
    3. {
    4. public:
    5. 	//拷贝构造函数（全缺省）
    6. 	Date(int year = 1949, int month = 10, int day = 1);
    7. 	//获取某一个月的天数
    8. 	int GetMonthDay(int year, int month) const;
    9. 	//-=运算符重载
    10. 	Date& operator-=(int day);
    11. 	//-运算符重载
    12. 	Date operator-(int day) const;
    13. private:
    14. 	int _year;  //年
    15. 	int _month; //月
    16. 	int _day;   //日
    17. };

    源文件：Date.cpp

    1. //获取某一个月的天数
    2. int Date::GetMonthDay(int year, int month) const
    3. {
    4. 	const static int MonthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    5. 	if (month == 2
    6. 		&& (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    7. 	{
    8. 		return 29;
    9. 	}
    10. 	return MonthArray[month];
    11. }
    12. //-=运算符重载
    13. Date& Date::operator-=(int day)
    14. {
    15. 	_day -= day;
    16. 	while (_day <= 0)
    17. 	{
    18. 		//向月份借位
    19. 		--_month;
    20. 		if (_month == 0)
    21. 		{
    22. 			//向年份借位
    23. 			--_year;
    24. 			_month = 12;
    25. 		}
    26. 		_day += GetMonthDay(_year, _month);
    27. 	}
    28. 	return *this;
    29. }
    30. //-运算符重载
    31. Date Date::operator-(int day) const
    32. {
    33. 	Date tmp(*this);
    34. 	tmp -= day;
    35. 	return tmp;
    36. }

     3.3 日期+、-天数的优化版本

    上面实现的这两个运算符重载还是有一定的缺陷的，万一有的人在+天数时传递负值就会出现问题，如果有人在-天数的时候传递负值也是会出现bug，那么就需要再次进行优化。

    当使用日期+天数时传递负值直接复用-=操作 

    当使用日期-天数时传递负值直接复用+=操作 

    1. //+=运算符重载
    2. Date& Date::operator+=(int day)
    3. {
    4. 	//负值天数操作
    5. 	if (day < 0)
    6. 	{
    7. 		return *this -= (-day);
    8. 	}
    9. 	_day += day;
    10. 	//判断天数的合理性
    11. 	while (_day > GetMonthDay(_year, _month))
    12. 	{
    13. 		_day -= GetMonthDay(_year, _month);
    14. 		++_month;  //天满了进位月份
    15. 		if (_month == 13)
    16. 		{
    17. 			++_year;   //月份满了进位年份
    18. 			_month = 1;
    19. 		}
    20. 	}
    21. 	return *this;
    22. }
    23.  
    24. //-=运算符重载
    25. Date& Date::operator-=(int day)
    26. {
    27. 	//负值天数操作
    28. 	if (day < 0)
    29. 	{
    30. 		return *this += (-day);
    31. 	}
    32. 	_day -= day;
    33. 	while (_day <= 0)
    34. 	{
    35. 		//向月份借位
    36. 		--_month;
    37. 		if (_month == 0)
    38. 		{
    39. 			//向年份借位
    40. 			--_year;
    41. 			_month = 12;
    42. 		}
    43. 		_day += GetMonthDay(_year, _month);
    44. 	}
    45. 	return *this;
    46. }

    3.4 前置++、后置++、前置--、后置--

    上篇的文章中提到过前置和后置的区别就是后置++多了一个int参数

    头文件：Date.h

    1. //日期类
    2. class Date
    3. {
    4. public:
    5. 	//前置++运算符重载
    6. 	Date& operator++();
    7. 	//后置++运算符重载
    8. 	Date operator++(int) const;
    9. 	//前置--运算符重载
    10. 	Date& operator--();
    11. 	//后置--运算符重载
    12. 	Date operator--(int) const;
    13. private:
    14. 	int _year;  //年
    15. 	int _month; //月
    16. 	int _day;   //日
    17. };

    源文件：Date.cpp

    1. //前置++运算符重载
    2. Date& Date::operator++()
    3. {
    4. 	*this += 1;
    5. 	return *this;
    6. }
    7. //后置++运算符重载
    8. Date Date::operator++(int) const
    9. {
    10. 	Date tmp(*this);
    11. 	tmp += 1;
    12. 	return tmp;
    13. }
    14. //前置--运算符重载
    15. Date& Date::operator--()
    16. {
    17. 	*this -= 1;
    18. 	return *this;
    19. }
    20. //后置--运算符重载
    21. Date Date::operator--(int) const
    22. {
    23. 	Date tmp(*this);
    24. 	tmp -= 1;
    25. 	return tmp;
    26. }

    3.5 日期与日期相差天数

    日期与日期相差天数也是使用-的运算符重载，日期-日期这里可以直接减，也可以使用两个日期同时减去2000年1月1日，然后根据差值计算天数，需要注意的是日期-日期是会出现负数的。还有一种比较简单的方法计数法：设置一个标志值记录正负，然后记录两个日期当中最大的一个日期，然后设置一个计数值，将小日期加1，同时也将计数值加1，直到小日期加到和大日期相等，那么此时这个计数值就是它们之间相差的日期。

    源文件：Date.cpp

    1. //日期-日期
    2. int Date::operator-(const Date& d) const
    3. {
    4. 	Date dmax = *this;
    5. 	Date dmin = d;
    6. 	int flag = 1;  //记录正负
    7. 	//找出较大的日期
    8. 	if (*this < d)
    9. 	{
    10. 		dmax = d;
    11. 		dmin = *this;
    12. 		flag = -1;
    13. 	}
    14. 	//设置计数值
    15. 	int coutN = 0;
    16. 	while (dmin != dmax)
    17. 	{
    18. 		++dmin;
    19. 		++coutN;
    20. 	}
    21. 	//将差值再*记录值
    22. 	return coutN * flag;
    23. }

    4. 流提取、流插入运算符重载

    如果我们使用cout来直接打印日期类的话是不能打印的，同样的使用cin来对日期类输入也是不支持的，因为日期类是不属于内置类型的，如果我们也要像内置类型一样使用cin和cout就需要对>>(流提取)和<<(流插入)进行重载

    cin是一个istream类中的对象，内置类型能使用流提取的原因就是库里面将内置类型都进行重载了。

    cout是一个ostream类中的对象

    4.1 流插入

    我们要实现自定义类型的流插入就需要用到库里面的流插入来进行辅助：

    1. //头文件：Date.h
    2.  
    3. //日期类
    4. class Date
    5. {
    6. public: 
    7. 	//拷贝构造函数（全缺省）
    8. 	Date(int year = 1949, int month = 10, int day = 1);
    9. 	//打印函数
    10.  
    11. 	//流插入
    12. 	void operator<<(ostream& out);
    13.  
    14. private:
    15. 	int _year;  //年
    16. 	int _month; //月
    17. 	int _day;   //日
    18. };
    19.  
    20.  
    21. //源文件：Date.cpp
    22. //流插入
    23. void Date::operator<<(ostream& out)
    24. {
    25. 	out << _year << "/" << _month << "/" << _day << endl;
    26. }

    如果这样子写的话会出现一个问题：我们正常调用会调用不了：

    类成员函数的第一个参数是隐藏的this指针，所以正常调用的话跟重载的顺序不匹配：

    实现为这样非要调用的话只需要将顺序换一下即可：

    但是这样子调用又不符合日常调用习惯，所以我们需要将两个参数的位置调换，但是类成员函数的第一个函数是默认隐藏的，所以需要调换的话就需要写为全局运算符重载函数，但是设为全局又存在一个新的问题，类中的私有函数在类外面不能访问，这里有两种方法：

    1. 使用单独的函数将年份、月份、天数都分别保存起来直接使用。

    2. 将流插入运算符重载设置为友元函数。

    在这里我们使用第二种方法：

    1. //头文件：Date.h
    2. //日期类
    3. class Date
    4. {
    5. 	//友元声明
    6. 	friend void operator<<(ostream& out, const Date& d);
    7.  
    8. public:
    9. 	//拷贝构造函数（全缺省）
    10. 	Date(int year = 1949, int month = 10, int day = 1);
    11.     //...
    12. private:
    13. 	int _year;  //年
    14. 	int _month; //月
    15. 	int _day;   //日
    16. };
    17.  
    18. //流插入
    19. void operator<<(ostream& out, const Date& dt);
    20.  
    21. //源文件：Date.cpp
    22. //流插入
    23. void operator<<(ostream& out, const Date& d)
    24. {
    25. 	out << d._year << "/" << d._month << "/" << d._day << endl;
    26. }

    这样写的话还是存在一个小小的问题：每次输出的话只能一个一个日期类进行输出，不能一次性输出多个：

    这个问题的主要原因是前面的输出d1是一个正常的运算符重载，而这个运算符重载的返回值又是void，而接下来的运算符重载不认识void类型，所以需要返回一个ostream类型才能完成下面的输出。

    完整的优化代码：

    头文件：Date.h

    1. //日期类
    2. class Date
    3. {
    4. 	//友元声明
    5. 	friend ostream& operator<<(ostream& out, const Date& d);
    6.  
    7. public:
    8. 	//不涉及内部数据的修改的函数可以加上const修饰
    9. 	 
    10. 	//拷贝构造函数（全缺省）
    11. 	Date(int year = 1949, int month = 10, int day = 1);
    12. 	//...
    13. private:
    14. 	int _year;  //年
    15. 	int _month; //月
    16. 	int _day;   //日
    17. };
    18.  
    19. //流插入
    20. ostream& operator<<(ostream& out, const Date& d);

    源文件：Date.cpp

    1. //流插入
    2. ostream& operator<<(ostream& out, const Date& d)
    3. {
    4. 	out << d._year << "/" << d._month << "/" << d._day << endl;
    5. 	return out;
    6. }

    4.2 流提取

    cin是一个istream类中的对象，所以我们可以借助istream来实现对于日期类的输入：

    头文件：Date.h

    1. //日期类
    2. class Date
    3. {
    4. 	//友元声明
    5. 	friend ostream& operator<<(ostream& out, const Date& d);
    6. 	friend istream& operator>>(istream& in, Date& d);
    7.  
    8. public:
    9. 	//不涉及内部数据的修改的函数可以加上const修饰
    10. 	 
    11. 	//拷贝构造函数（全缺省）
    12. 	Date(int year = 1949, int month = 10, int day = 1);
    13.     //...
    14. private:
    15. 	int _year;  //年
    16. 	int _month; //月
    17. 	int _day;   //日
    18. };
    19.  
    20. //流插入
    21. ostream& operator<<(ostream& out, const Date& d);
    22. //流提取
    23. istream& operator>>(istream& in, Date& d);

    源文件：Dtae.cpp

    1.  
    2. //流插入
    3. ostream& operator<<(ostream& out, const Date& d)
    4. {
    5. 	out << d._year << "/" << d._month << "/" << d._day << endl;
    6. 	return out;
    7. }
    8. //流提取
    9. istream& operator>>(istream& in, Date& d)
    10. {
    11. 	in >> d._year >> d._month >> d._day;
    12. 	return in;
    13. }

    5. 完整代码

    头文件：Date.h

    1. #pragma once
    2. #include 
    3. using namespace std;
    4.  
    5. //日期类
    6. class Date
    7. {
    8. 	//友元声明
    9. 	friend ostream& operator<<(ostream& out, const Date& d);
    10. 	friend istream& operator>>(istream& in, Date& d);
    11.  
    12. public:
    13. 	//不涉及内部数据的修改的函数可以加上const修饰
    14. 	 
    15. 	//拷贝构造函数（全缺省）
    16. 	Date(int year = 1949, int month = 10, int day = 1);
    17. 	//打印函数
    18. 	void Print() const;
    19. 	//获取某一个月的天数
    20. 	int GetMonthDay(int year, int month) const;
    21.  
    22. 	//==运算符重载
    23. 	bool operator==(const Date& d) const;
    24. 	//!=运算符重载
    25. 	bool operator!=(const Date& d) const;
    26. 	//<运算符重载
    27. 	bool operator<(const Date& d) const;
    28. 	//<=运算符重载
    29. 	bool operator<=(const Date& d) const;
    30. 	//>运算符重载
    31. 	bool operator>(const Date& d) const;
    32. 	//>=运算符重载
    33. 	bool operator>=(const Date& d) const;
    34.  
    35. 	//+=运算符重载
    36. 	Date& operator+=(int day);
    37. 	//+运算符重载
    38. 	Date operator+(int day) const;
    39.  
    40. 	//-=运算符重载
    41. 	Date& operator-=(int day);
    42. 	//-运算符重载
    43. 	Date operator-(int day) const;
    44.  
    45. 	//前置++运算符重载
    46. 	Date& operator++();
    47. 	//后置++运算符重载
    48. 	Date operator++(int) const;
    49. 	//前置--运算符重载
    50. 	Date& operator--();
    51. 	//后置--运算符重载
    52. 	Date operator--(int) const;
    53.  
    54. 	//日期-日期
    55. 	int operator-(const Date& d) const;
    56. private:
    57. 	int _year;  //年
    58. 	int _month; //月
    59. 	int _day;   //日
    60. };
    61.  
    62. //流插入
    63. ostream& operator<<(ostream& out, const Date& d);
    64. //流提取
    65. istream& operator>>(istream& in, Date& d);

    源文件：Date.cpp

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"Date.h"
    3.  
    4. //拷贝构造函数（全缺省）
    5. Date::Date(int year, int month, int day)
    6. {
    7. 	_year = year;
    8. 	_month = month;
    9. 	_day = day;
    10. }
    11. //打印函数
    12. void Date::Print() const
    13. {
    14. 	cout << _year << "/" << _month << "/" << _day << endl;
    15. }
    16.  
    17. //==运算符重载
    18. bool Date::operator==(const Date& d) const
    19. {
    20. 	return _year == d._year
    21. 		&& _month == d._month
    22. 		&& _day == d._day;
    23. }
    24. //!=运算符重载
    25. bool Date::operator!=(const Date& d) const
    26. {
    27. 	return !(*this == d);
    28. }
    29. //<运算符重载
    30. bool Date::operator<(const Date& d) const
    31. {
    32. 	if (_year < d._year)
    33. 	{
    34. 		return true;
    35. 	}
    36. 	else if (_year == d._year && _month < d._month)
    37. 	{
    38. 		return true;
    39. 	}
    40. 	else if (_year == d._year && _month == d._month && _day < d._day)
    41. 	{
    42. 		return true;
    43. 	}
    44. 	else
    45. 	{
    46. 		return false;
    47. 	}
    48. }
    49. //<=运算符重载
    50. bool Date::operator<=(const Date& d) const
    51. {
    52. 	return *this == d || *this < d;
    53. }
    54. //>运算符重载
    55. bool Date::operator>(const Date& d) const
    56. {
    57. 	return !(*this <= d);
    58. }
    59. //>=运算符重载
    60. bool Date::operator>=(const Date& d) const
    61. {
    62. 	return !(*this < d);
    63. }
    64.  
    65. //获取某一个月的天数
    66. int Date::GetMonthDay(int year, int month) const
    67. {
    68. 	const static int MonthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    69. 	if (month == 2
    70. 		&& (year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
    71. 	{
    72. 		return 29;
    73. 	}
    74. 	return MonthArray[month];
    75. }
    76. //+=运算符重载
    77. Date& Date::operator+=(int day)
    78. {
    79. 	//负值天数操作
    80. 	if (day < 0)
    81. 	{
    82. 		return *this -= (-day);
    83. 	}
    84. 	_day += day;
    85. 	//判断天数的合理性
    86. 	while (_day > GetMonthDay(_year, _month))
    87. 	{
    88. 		_day -= GetMonthDay(_year, _month);
    89. 		++_month;  //天满了进位月份
    90. 		if (_month == 13)
    91. 		{
    92. 			++_year;   //月份满了进位年份
    93. 			_month = 1;
    94. 		}
    95. 	}
    96. 	return *this;
    97. }
    98. //+运算符重载
    99. Date Date::operator+(int day) const
    100. {
    101. 	//构造一个新的Date
    102. 	Date tmp(*this);
    103. 	tmp += day;
    104. 	return tmp;
    105. }
    106.  
    107. //-=运算符重载
    108. Date& Date::operator-=(int day)
    109. {
    110. 	//负值天数操作
    111. 	if (day < 0)
    112. 	{
    113. 		return *this += (-day);
    114. 	}
    115. 	_day -= day;
    116. 	while (_day <= 0)
    117. 	{
    118. 		//向月份借位
    119. 		--_month;
    120. 		if (_month == 0)
    121. 		{
    122. 			//向年份借位
    123. 			--_year;
    124. 			_month = 12;
    125. 		}
    126. 		_day += GetMonthDay(_year, _month);
    127. 	}
    128. 	return *this;
    129. }
    130. //-运算符重载
    131. Date Date::operator-(int day) const
    132. {
    133. 	Date tmp(*this);
    134. 	tmp -= day;
    135. 	return tmp;
    136. }
    137.  
    138. //前置++运算符重载
    139. Date& Date::operator++()
    140. {
    141. 	*this += 1;
    142. 	return *this;
    143. }
    144. //后置++运算符重载
    145. Date Date::operator++(int) const
    146. {
    147. 	Date tmp(*this);
    148. 	tmp += 1;
    149. 	return tmp;
    150. }
    151. //前置--运算符重载
    152. Date& Date::operator--()
    153. {
    154. 	*this -= 1;
    155. 	return *this;
    156. }
    157. //后置--运算符重载
    158. Date Date::operator--(int) const
    159. {
    160. 	Date tmp(*this);
    161. 	tmp -= 1;
    162. 	return tmp;
    163. }
    164.  
    165. //日期-日期
    166. int Date::operator-(const Date& d) const
    167. {
    168. 	Date dmax = *this;
    169. 	Date dmin = d;
    170. 	int flag = 1;  //记录正负
    171. 	//找出较大的日期
    172. 	if (*this < d)
    173. 	{
    174. 		dmax = d;
    175. 		dmin = *this;
    176. 		flag = -1;
    177. 	}
    178. 	//设置计数值
    179. 	int coutN = 0;
    180. 	while (dmin != dmax)
    181. 	{
    182. 		++dmin;
    183. 		++coutN;
    184. 	}
    185. 	//将差值再*记录值
    186. 	return coutN * flag;
    187. }
    188.  
    189. //流插入
    190. ostream& operator<<(ostream& out, const Date& d)
    191. {
    192. 	out << d._year << "/" << d._month << "/" << d._day << endl;
    193. 	return out;
    194. }
    195. //流提取
    196. istream& operator>>(istream& in, Date& d)
    197. {
    198. 	in >> d._year >> d._month >> d._day;
    199. 	return in;
    200. }

    朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，欲知后事如何，请听下回分解~，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！

  • 相关阅读:
    [英雄星球七月集训LeetCode解题日报] 第5日 双指针
    ubunut搭建aarch64 cuda交叉编译环境记录
    【大数据入门核心技术-Hive】Hive3.1.2高可用集群搭建
    JavaSE：String类
    对象分配规则
    Docker 及 Docker Compose 安装指南
    全球创新创业数据国内版
    对zygote的理解
    Java模板方法模式源码剖析及使用场景
    js录制屏幕并输出视频
  • 原文地址：https://blog.csdn.net/Yikefore/article/details/133611275