如果下面博客有不理解的地方，可以查看源码：代码提交：日期类的实现

1. 构造函数的实现

由于系统实现的默认构造函数即便采用默认值的形式也只能存在1个固定的默认日期（例如：1997-1-1）。所以，构造函数需要显示实现

//判断日期是否正确
bool Date::IsTrueDate(int year, int month, int day)
{static int arr[13] = { 0,31,29,31,30,31,30,31,31,30,31,30,31 };if (month > 12)return false;if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) && month == 2){if (day > 28){return false;}}if (day > arr[month])return false;return true;
}

class Date
{
public:// 声明定义分离bool IsTrueDate(int year, int month, int day);Date(int year = 2023,int month = 3,int day = 18){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};

默认构造函数有三类：无参，全缺省参数，系统默认生成
这边采用的是全缺省的方式：要根据传递过来的参数来实现不同的日期
声明与定义是否需要分离？
对于频繁调用的接口（例如：构造函数），推荐声明与定义不分离，编译器将其转化为内联函数(inline)，在调用的地方直接展开（减少拷贝，提高效率）
对于不频繁调用且冗余的接口，推荐分离，因为不方便展开（展开会显得代码太长）

2. 析构函数

由于没有资源的申请，所以不需要手动实现析构函数，采用系统默认的即可

3. 拷贝构造函数

因为编译器默认生成的拷贝为浅拷贝，可以满足需求，所以可以不需要实现 但是日期类的

	//隐藏的this指针 Date(Date* const this,const Date& d) //Date d2(d1)Date(const Date& d){_year = d._year;_month = d._month;_day = d._day;}

4. 赋值重载

因为编译器默认生成的拷贝为浅拷贝，可以满足需求，所以可以不需要实现

5. Print

	void Print(){cout << _year << "-" << _month << "-" << _day << endl;}

TestDate01

6. 重载 == (operator==)

	bool operator==(const Date& d) const{return _year == d._year&& _month == d._month&& _day == d._day;}

为啥末尾要加const修饰呢？
末尾加上const修饰其实修饰的是隐藏的this指针，因为==的运算符重载不会改变this指针所指向的内容。
加上const修饰之后，可以保护数据不被修改，增加代码的健壮性。

7. 重载 > (operator>)

声明与定义分离

	bool operator>(const Date& d) const;

bool Date::operator>(const Date& d) const
{if (_year > d._year)return true;if (_year == d._year && _month > d._month)return true;if (_year == d._year && _month == d._month && _day > d._day)return true;return false;
}

8. 重载 >= (operator>=)

	bool operator>=(const Date& d) const;

bool Date::operator>=(const Date& d) const
{// 接口的复用 operator== 和 operator>return (*this == d) || (*this > d);
}

9. 重载 != (operator!=)

	bool operator!=(const Date& d) const;

bool Date::operator!=(const Date& d) const
{return !(*this == d);
}

10. 重载 < (operator<)

	bool operator<(const Date& d) const;

bool Date::operator<(const Date& d) const
{return !(*this >= d);
}

11. 重载 <= (operator<)

	bool operator<=(const Date& d) const;

bool Date::operator<=(const Date& d) const
{return (*this < d) && (*this == d);
}

TestDate02

12. 重载 += (operator+=)

//在Date.cpp中定义
int GetMonthDay(int year, int month)
{static int monthDayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))){return 29;}else{return monthDayArray[month];}
}
Date& Date::operator+=(int day)
{//加个判断if (day < 0){// 接口复用 operator-= // 因为天数小于0，所以带负号*this -= -day;}_day += day;while (_day > GetMonthDay(_year, _month)){_day -= GetMonthDay(_year, _month);_month++;if (_month > 12){_year++;_month = 1;}}return *this;
}

13. 重载 -= (operator-=)

	Date& operator-=(int day);

Date& Date::operator-=(int day)
{//加个判断if (day < 0){// 接口复用 operator+= // 因为天数小于0，所以带负号*this += -day;}_day -= day;while (_day < 0){_day += GetMonthDay(_year, _month-1);_month--;if (_month < 1){_year--;_month = 13;}}return *this;
}

14. 重载 - (operator-)

	Date operator-(int day);

Date Date::operator-(int day)
{	//拷贝构造 ret对象Date ret = *this;//重载-=ret -= day;return ret;
}

为啥这边operator-的返回值是Date(传值返回) 而不是传引用返回呢？
因为-操作并不会影响this指针指向对象的值，所以需要拷贝构造一个临时变量进行操作符运算

15. 重载 + (operator+)

Date Date::operator+(int day)
{//拷贝构造 ret对象Date ret = *this;//重载+=ret += day;return ret;
}

TestDate03

16. 重载 后置++ (operator++)

	// 后置++Date operator++(int);

// 后置++
Date Date::operator++(int)
{Date ret = *this;*this += 1;return ret;
}

为啥后置++要传值返回呢？前置++可以传引用返回呢
因为后置++是先返回值，再进行++操作。
而前置++是先++，再返回++后的值。

17. 重载 前置++(operator++)(int)

	// 前置++Date& operator++();

// 前置++
Date& Date::operator++()
{*this += 1;return *this;
}

18. 重载 后置-- (operator--)

	// 后置--Date operator--(int);

// 后置--
Date Date::operator--(int)
{Date ret = *this;*this -= 1;return ret;
}

19. 重载 前置-- (operator--)(int)

	// 前置--Date& operator--();

// 前置--
Date& Date::operator--()
{*this -= 1;return *this;
}

TestDate04

20. 重载- (operator-)

	// 日期减int operator-(const Date& d);

int Date::operator-(const Date& d)
{//在二者中找一个小的日期类不断++ 直到与大的日期相等即可int date = 0;// 假设this大 d小Date max = *this;Date min = d;if (max < min){// this小 d大 max = d;min = *this;}while (min != max){++date;++min;}return date;
}

TestDate05

21. 流插入重载 (operator<<)

因为流插入，流提取的操作符是cout<<d1 cin >>d1，是将类型流向控制台或者从控制台提取出来，所以不能实现成成员函数，否则就是d1.operator<<(d1<<cout) 不符合实际 所以将其实现成全局函数

在类中任意位置声明友元函数即可。

class Date
{// 友元声明（类的任意位置）friend ostream& operator<<(ostream& out, const Date& d);friend istream& operator>>(istream& out, Date& d);//....

这里的operator>>参数为啥是Date& 而不是const Date& 呢？
因为流插入就是要修改Date对象的，所以不能拿const修饰

inline ostream& operator<<(ostream& out, const Date& d)
{out << d._year << "-" << d._month << "-" << d._day << endl;return out;
}

这里能不能不设计成inline内联呢？
答案是不行的，因为该函数是定义在Date.h文件当中，而Date.h又会在两个文件中都引用，在编译阶段，Date.cpp 和 Test.cpp 两个文件当中的头文件分别展开 那么在链接的过程中，不加inline就会使函数出现在符号表当中，而两份代码会导致两个地址，出现链接错误。
所以必须要inline内联，或者定义成static静态函数，改变其链接属性，使其无法出现在符号表

这里函数要返回值是为啥？ostream&
是因为要连续赋值，cin >>d1>>d2;类似这种场景，如果不传返回值，则无法进行连续操作

22. 流提取重载 (operator>>)

inline istream& operator>>(istream& in, Date& d)
{in >> d._year >> d._month >> d._day;return in;
}

TestDate06

那么类的基本实现就完成啦\(^o^)/~ ，欢迎各位大佬指正，一起加油，共勉！！！