【四】【C++】日期类简单实现

编写GetMonthDay函数

int GetMonthDay(int year, int month) {
    static int monthDays[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;
    }
        return monthDays[month];
}

GetMonthDay函数用来获取指定year和month的天数。首先把一年中每个月的天数放入一个数组中存储，第二月填写28。我们知道闰年的二月是29天，非闰年的二月是28天。也就是一年中除了第二月，其他月份的天数都是固定的。如果我们指定的月份是二月，那么我们就需要在外面再判断一下指定的year是否是闰年，如果是闰年就返回29即可，不是闰年就返回数组中存储的第二月的天数28即可。如果不是二月，直接返回数组中存储的天数即可。

编写构造函数

Date(int year = 0, int month = 1, int day = 1) {
    if (year >= 0
        && month >= 1 && month <= 12
        && day >= 1 && day <= GetMonthDay(year, month)) {
        _year = year;
        _month = month;
        _day = day;
    } else {
        cout << "非法日期" << endl;
    }
}

当我们创建对象的时候，需要检测是否是非法日期。我们规定年份必须大于等于零，月份必须介于[1,12]之间，天数必须介于[1,GetMonthDay(year, month)]之间。

编写“<”运算符重载

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

如果d1、d2都是日期类对象，我们希望d1<d2表示d1对象的日期小于d2对象的日期。

编写“==”运算符重载

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

如果d1、d2都是日期类对象，我们希望d1==d2表示d1对象的日期等于d2对象的日期。

编写“<=”运算符重载

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

如果d1、d2都是日期类对象，我们希望d1<=d2表示d1对象的日期小于等于d2对象的日期。

此时我们可以选择复用"<"和"=="运算符重载，d1<=d2等价于d1<d2||d1==d2。

而d1<d2以及d1==d2这两个运算符重载我们已经编写好了。

编写“>"运算符重载

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

如果d1、d2都是日期类对象，我们希望d1>d2表示d1对象的日期大于d2对象的日期。

此时我们可以选择复用"<="运算符重载，d1>d2等价于!(d1<=d2)。

而d1<=d2这个运算符重载我们已经编写好了。

编写">="运算符重载

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

如果d1、d2都是日期类对象，我们希望d1>=d2表示d1对象的日期大于等于d2对象的日期。

此时我们可以选择复用"<"运算符重载，d1>=d2等价于!(d1<d2)。

而d1<d2这个运算符重载我们已经编写好了。

编写"!="运算符重载

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

如果d1、d2都是日期类对象，我们希望d1！=d2表示d1对象的日期不等于d2对象的日期。

此时我们可以选择复用"=="运算符重载，d1！=d2等价于!(d1==d2)。

而d1==d2这个运算符重载我们已经编写好了。

编写“+=”运算符重载

        Date& operator+=(int day) {
            if (day < 0) {
                return (*this) -= -day;
            }
            _day += day;
            while (_day > GetMonthDay(_year, _month)) {
                _day -= GetMonthDay(_year, _month);
                _month++;
                if (_month == 13) {
                    _year++;
                    _month = 1;
                }
            }
            return *this;
        }

如果d1是日期类对象，我们希望d1+=day表示d1的日期加上day天。

如果day>=0，正常把day加到d1日期上即可，如果day<0,我们可以把+=一个负数转化为-=一个正数。即

-=（-day）。把对负数的处理转化为对正数的处理即可。

我们先一次性把day加到d1的_day上，如果_day超过了该year和month对应的天数最大值，说明需要进位，此时_day天数减去该year和month对应的天数最大值，对month进行进位。接着对_day判断，以此类推，一直到_day是合法天数为止。

注意，最后需要返回d1，而函数返回值是日期类的引用。函数返回值是日期类引用是因为，可以使用引用尽可能使用引用，使用引用可以减少不必要的拷贝构造过程，提升效率。函数返回d1是因为，"d2=d1+=day",为了支持连续操作。

编写“+”运算符重载

        Date operator+(int day) {
            if (day < 0) {
                return (*this) - (-day);
            }
            Date ret(*this);
            ret += day;
            return ret;
        }

如果d1是日期类对象，我们希望d1+day表示d1的日期加上day天，但是d1类中的日期不变。

如果day是正数，正常进行操作。如果day是负数，我们可以将+一个负数转化为-一个正数，从而处理正数，即+day等价于-（-day）。

“+”和“+=”的区别在于，我们不可以改变d1的日期值，但是我们需要返回加上day之后的日期值，因此我们可以拷贝构造一个临时对象ret，对ret进行+=day操作，我们改变了ret的日期值，得到了加上day之后的日期值，同时没有改变d1的日期值，此时我们返回ret即可。

注意函数的返回值不是引用类型，原因是这里不能使用引用，因为ret对象出了作用域就消失了。

编写“-=”运算符重载

        Date& operator-=(int day) {
            if (day < 0) {
                return (*this) += -day;
            }
            _day -= day;
            while (_day <= 0) {
                _month--;
                if (_month == 0) {
                    _year--;
                    _month = 12;
                }
                _day += GetMonthDay(_year, _month);
            }
            return *this;
        }

如果d1是日期类对象，我们希望d1-=day表示d1的日期减去day天。

如果day>=0，正常用d1的日期减去day即可，如果day<0,我们可以把-=一个负数转化为+=一个正数。即

+=（-day）。把对负数的处理转化为对正数的处理即可。

我们先一次性用d1日期的_day减去day，如果_day<=0表示原_day不够减，需要借位，此时_month--，借的天数是上一个月即_month--后的天数。接着判断_day是否合法，以此类推，直到_day合法为止。

注意，最后需要返回d1，而函数返回值是日期类的引用。函数返回值是日期类引用是因为，可以使用引用尽可能使用引用，使用引用可以减少不必要的拷贝构造过程，提升效率。函数返回d1是因为，"d2=d1-=day",为了支持连续操作。

编写“-”运算符重载

        Date operator-(int day) {
            if (day < 0) {
                return (*this) + (-day);
            }
            Date ret(*this);
            ret -= day;
            return ret;
        }

如果d1是日期类对象，我们希望d1-day表示d1的日期减去day天，但是d1类中的日期不变。

如果day是正数，正常进行操作。如果day是负数，我们可以将-一个负数转化为+一个正数，从而处理正数，即-day等价于+（-day）。

“-”和“-=”的区别在于，我们不可以改变d1的日期值，但是我们需要返回减去day之后的日期值，因此我们可以拷贝构造一个临时对象ret，对ret进行-=day操作，我们改变了ret的日期值，得到了减去day之后的日期值，同时没有改变d1的日期值，此时我们返回ret即可。

注意函数的返回值不是引用类型，原因是这里不能使用引用，因为ret对象出了作用域就消失了。

编写“前置++”运算符重载

        Date& operator++() {
            (*this) += 1;
            return *this;
        }

如果d1是日期类对象，我们希望++d1表示d1的日期加上1天后的日期。

复用“+=”运算符重载即可。

编写“后置++”运算符重载

        Date operator++(int) {
            Date ret(*this);
            (*this) += 1;
            return ret;
        }

如果d1是日期类对象，我们希望d1++表示d1的日期加上1天后的日期，但是返回的是++前的日期值。

我们可以拷贝构造一个ret，复用“+=”运算符重载即可。

编写“前置--”运算符重载

        Date& operator--() {
            (*this) -= 1;
            return *this;
        }

如果d1是日期类对象，我们希望--d1表示d1的日期减去1天后的日期。

复用“-=”运算符重载即可。

编写“后置--”运算符重载

        Date operator--(int) {
            Date ret(*this);
            (*this) -= 1;
            return ret;
        }

如果d1是日期类对象，我们希望d1--返回--前的日期，但是d1的日期之后会减去一天。

我们可以拷贝构造一个ret，复用“-=”运算符重载即可。

日期类完整代码实现

/*日期类代码实现*/
#include <iostream>
using namespace std;
class Date {
    public:
        int GetMonthDay(int year, int month) {
    static int monthDays[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;
            }
            return monthDays[month];
        }
        Date(int year = 0, int month = 1, int day = 1) {
            if (year >= 0
                && month >= 1 && month <= 12
                && day >= 1 && day <= GetMonthDay(year, month)) {
                _year = year;
                _month = month;
                _day = day;
            } else {
                cout << "非法日期" << endl;
            }
        }
        bool operator<(const Date& d) {
            if (_year < d._year)
                return true;
            else if (_year == d._year && _month < d._month)
                return true;
            else if (_year == d._year && _month == d._month && _day < d._day)
                return true;
            else
                return false;
        }
        bool operator==(const Date& d) {
            return _year == d._year && _month == d._month && _day == d._day;
        }
        bool operator<=(const Date& d) {
            return (*this) < d || (*this) == d;
        }
        bool operator>(const Date& d) {
            return !((*this) <= d);
        }
        bool operator>=(const Date& d) {
            return !((*this) < d);
        }
        bool operator!=(const Date& d) {
            return !((*this) == d);
        }
        Date& operator+=(int day) {
            if (day < 0) {
                return (*this) -= -day;
            }
            _day += day;
            while (_day > GetMonthDay(_year, _month)) {
                _day -= GetMonthDay(_year, _month);
                _month++;
                if (_month == 13) {
                    _year++;
                    _month = 1;
                }
            }
            return *this;
        }
        Date operator+(int day) {
            if (day < 0) {
                return (*this) - (-day);
            }
            Date ret(*this);
            ret += day;
            return ret;
        }
        Date& operator-=(int day) {
            if (day < 0) {
                return (*this) += -day;
            }
            _day -= day;
            while (_day <= 0) {
                _month--;
                if (_month == 0) {
                    _year--;
                    _month = 12;
                }
                _day += GetMonthDay(_year, _month);
            }
            return *this;
        }
        Date operator-(int day) {
            if (day < 0) {
                return (*this) + (-day);
            }
            Date ret(*this);
            ret -= day;
            return ret;
        }
        Date& operator++() {
            (*this) += 1;
            return *this;
        }
        Date operator++(int) {
            Date ret(*this);
            (*this) += 1;
            return ret;
        }
        Date& operator--() {
            (*this) -= 1;
            return *this;
        }
        Date operator--(int) {
            Date ret(*this);
            (*this) -= 1;
            return ret;
        }
        void Show() {
            cout << _year << "-" << _month << "-" << _day << endl;
        }
    private:
        int _year;
        int _month;
        int _day;
 };
void Test() {
    Date d1(2024, 2, 28);
    d1.Show();
    Date d2 = --d1;
    d2.Show();

 }
int main() {
    Test();
    return 0;
 }

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

谢谢您的支持，期待与您在下一篇文章中再次相遇！