C++ 日期类设计与 const 成员函数实践

由于成员变量都是内置类型且无动态资源申请，浅拷贝和自动销毁机制完全适用。不过在实际工程中，建议将声明与定义分离，并添加必要的自检查逻辑。

获取某年某月的天数

计算日期最基础的功能是判断当月天数。由于成员变量私有化，该接口需在类内部或作为友元实现。这里采用静态辅助函数的形式：

// 获取某年某月的天数
int GetMonthDay(int year, int month) {
    static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    
    // 闰年判断：能被 4 整除但不能被 100 整除，或者能被 400 整除
    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) {
        return 29;
    }
    return days[month];
}

注意数组下标 0 位置预留了 0，这样月份索引可以直接对应数组下标，减少转换开销。闰年的二月单独处理为 29 天。

日期加减天数

实现日期运算时，通常先实现复合赋值运算符（如 +=），再基于其实现普通运算符（如 +），这样可以复用逻辑。

// 日期 += 天数
Date& operator+=(int day) {
    _day += day;
    while (_day > GetMonthDay(_year, _month)) {
        _day -= GetMonthDay(_year, _month);
        _month++;
        if (_month > 12) {
            _year++;
            _month = 1;
        }
    }
    return *this;
}

// 日期 + 天数
Date operator+(int day) {
    Date tmp(*this);
    tmp += day;
    return tmp;
}

给 _day 加上偏移量后，通过循环减去当前月天数并进位，直到数值落在合法范围内。+ 操作返回临时对象，因此不能返回引用，因为原对象在表达式中不应被修改。

设计顺序的思考

关于先实现 operator+= 还是 operator+，从效率角度看，先实现 += 更优。如果先写 +，每次调用可能都需要重新分配或复制逻辑，而基于 += 实现 + 只需一次赋值操作，减少了不必要的拷贝开销。

日期减天数

减法逻辑与加法类似，先实现 -= 再复用：

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

// 日期 - 天数
Date operator-(int day) {
    Date tmp(*this);
    tmp -= day;
    return tmp;
}

只要 _day 小于等于 0，说明需要向月份借位。若月份减到 0，则需向年份借位，同时更新月份为 12。

前置与后置 ++/--

前置版本直接返回引用，后置版本需保留旧值并返回副本：

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

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

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

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

注意后置运算符的参数 int 仅用于区分重载，实际使用时会被忽略。返回值必须是对象而非局部变量的引用。

运算符重载

比较运算符只需实现核心的 > 和 ==，其余可复用：

// > 运算符重载
bool 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;
}

// == 运算符重载
bool operator==(const Date& d) const {
    return _year == d._year && _month == d._month && _day == d._day;
}

// >= 运算符重载
bool operator>=(const Date& d) const {
    return *this > d || *this == d;
}

// < 运算符重载
bool operator<(const Date& d) const {
    return !(*this >= d);
}

// <= 运算符重载
bool operator<=(const Date& d) const {
    return !(*this > d);
}

// != 运算符重载
bool operator!=(const Date& d) const {
    return !(*this == d);
}

这种设计遵循 DRY（Don't Repeat Yourself）原则，减少维护成本。

日期差值计算优化

计算两个日期的相差天数有两种思路：

暴力法： 不断对较小日期执行 ++ 直到相等。虽然简单，但时间复杂度为 O(N)，效率较低。

优化法： 分别将两个日期回退到当年 1 月 1 日，计算剩余天数差，再累加中间年份的天数。

int operator-(const Date& d) const {
    Date max = *this;
    Date min = d;
    int flag = 1;

    // 确保 max 为大日期
    if (*this < d) {
        max = d;
        min = *this;
        flag = -1;
    }

    int count = 0;
    
    // max 减到当年 1 月 1 日
    while (!(max._day == 1 && max._month == 1)) {
        --max;
        ++count;
    }
    
    // min 减到当年 1 月 1 日
    while (!(min._day == 1 && min._month == 1)) {
        --min;
        --count;
    }

    // 计算年份差的总天数
    while (min._year != max._year) {
        // 复用闰年判断逻辑
        bool isLeap = (min._year % 4 == 0 && min._year % 100 != 0) || (min._year % 400 == 0);
        count += isLeap ? 366 : 365;
        min._year++;
    }

    return flag * count;
}

此方法将年份差计算转化为常数级循环，整体时间复杂度接近 O(1)，适合大规模日期运算场景。

流插入与提取运算符

为了让自定义类型支持标准 IO 流，需重载 << 和 >>。注意流对象不可拷贝，必须使用引用传递。

// 流插入运算符
std::ostream& operator<<(std::ostream& out, const Date& d) {
    out << d._year << '-' << d._month << '-' << d._day;
    return out;
}

// 流提取运算符
std::istream& operator>>(std::istream& in, Date& d) {
    int year, month, day;
    in >> year >> month >> day;
    
    if (month > 0 && month < 13 && day > 0 && day <= GetMonthDay(year, month)) {
        d._year = year;
        d._month = month;
        d._day = day;
    } else {
        std::cout << "非法日期" << std::endl;
        assert(0);
    }
    return in;
}

输入时进行合法性校验，输出时保持格式统一。链式调用依赖返回流的引用，这也是为什么参数和返回值都必须是引用的原因。