用日期类实现日期相减的c++ 代码

可以使用以下代码来实现日期相减：DateTime startDate = DateTime.Now;DateTime endDate = DateTime.Now.AddDays(-30);TimeSpan ts = startDate - endDate;double totalDays = ts.TotalDays;

相关问题

用c++实现一个日期类完成两个日期相减的功能

下面是一个用C++实现日期类的示例代码，包括两个日期相减的功能：

#include <iostream>
using namespace std;

class Date {
public:
    Date(int y, int m, int d) : year(y), month(m), day(d) {}
    int operator-(const Date& other) const {
        int days = 0;
        int y = year, m = month, d = day;
        while (y > other.year || (y == other.year && m > other.month) || (y == other.year && m == other.month && d > other.day)) {
            days++;
            d--;
            if (d == 0) {
                m--;
                if (m == 0) {
                    y--;
                    m = 12;
                }
                d = daysInMonth(y, m);
            }
        }
        return days;
    }
private:
    int year;
    int month;
    int day;
    bool isLeapYear(int y) const {
        return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
    }
    int daysInMonth(int y, int m) const {
        if (m == 2) {
            return isLeapYear(y) ? 29 : 28;
        } else if (m == 4 || m == 6 || m == 9 || m == 11) {
            return 30;
        } else {
            return 31;
        }
    }
};

int main() {
    Date d1(2021, 9, 1);
    Date d2(2021, 8, 1);
    int days = d1 - d2;
    cout << "d1 - d2 = " << days << endl;
    return 0;
}

在这个示例代码中，我们定义了一个日期类 `Date`，并实现了一个重载运算符 `-` 的函数，用于计算两个日期之间的天数差。在计算过程中，我们使用了一个循环来逐步减少日期，直到两个日期相等为止。我们还实现了两个辅助函数 `isLeapYear` 和 `daysInMonth`，分别用于判断某一年是否为闰年和某一月有多少天。

在 `main` 函数中，我们创建了两个日期对象 `d1` 和 `d2`，并计算它们之间的天数差，最后输出结果。

c++代码，设计一个日期类Date，包括年year、月month、日day三个私有数据成员，要求实现日期的基本运算、两个日期相减的天数、距现在向前一百天是哪天、距现在向后一百天是哪天

以下是设计的Date类的C++代码：

#include <iostream>
using namespace std;

class Date {
private:
    int year, month, day;
public:
    Date(int y, int m, int d) : year(y), month(m), day(d) {}
    int getYear() const { return year; }
    int getMonth() const { return month; }
    int getDay() const { return day; }

    int daysOfMonth() const {
        switch (month) {
        case 2:
            return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? 29 : 28;
        case 4:
        case 6:
        case 9:
        case 11:
            return 30;
        default:
            return 31;
        }
    }

    bool isValid() const {
        if (year < 1 || month < 1 || month > 12 || day < 1 || day > daysOfMonth()) {
            return false;
        }
        return true;
    }

    Date operator+(int days) const {
        Date result(year, month, day);
        while (days > 0) {
            int daysOfMonth = result.daysOfMonth();
            if (daysOfMonth - result.day < days) {
                // 需要进位到下一个月
                days -= daysOfMonth - result.day + 1;
                result.day = 1;
                if (++result.month > 12) {
                    result.month = 1;
                    ++result.year;
                }
            } else {
                // 不需要进位
                result.day += days;
                days = 0;
            }
        }
        return result;
    }

    int operator-(const Date& other) const {
        Date earlier = *this < other ? *this : other;
        Date later = *this > other ? *this : other;
        int days = 0;
        while (earlier != later) {
            ++earlier;
            ++days;
        }
        return *this < other ? -days : days;
    }

    bool operator==(const Date& other) const {
        return year == other.year && month == other.month && day == other.day;
    }

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

    bool operator<(const Date& other) const {
        if (year < other.year) {
            return true;
        } else if (year == other.year && month < other.month) {
            return true;
        } else if (year == other.year && month == other.month && day < other.day) {
            return true;
        }
        return false;
    }

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

    Date hundredDaysAgo() const {
        return *this - 100;
    }

    Date hundredDaysLater() const {
        return *this + 100;
    }
};

ostream& operator<<(ostream& os, const Date& date) {
    os << date.getYear() << '-' << date.getMonth() << '-' << date.getDay();
    return os;
}

int main() {
    Date d1(2022, 9, 28);
    cout << d1.hundredDaysAgo() << endl;
    cout << d1.hundredDaysLater() << endl;

    Date d2(2022, 9, 28);
    Date d3(2022, 9, 18);
    cout << (d2 - d3) << endl;

    return 0;
}

在这个实现中，我们定义了一个Date类，包含了年、月、日三个私有数据成员。类中包含了一些公有成员函数，可以进行日期的基本运算，比如相加、相减、比较大小等等。我们还实现了一个daysOfMonth函数，用来计算每个月有多少天。在main函数中，我们用一些简单的测试代码来测试我们的Date类的功能。