Location>code7788 >text

Date handling issues

Popularity：851 ℃/2025-03-14 17:50:51

Date processing is the most common requirement in software development, especially in scenarios where the difference in days between different dates is required. The accurate processing of dates is mainly after considering factors such as leap years and month-day changes.

We first define aDateStructure, including three member variables: year, month and day. The structure is simple and clear, suitable for storing date information:

struct Date { int y, m, d; };

Judgment of leap years

In date calculations, a leap year affects the number of days in February. According to the current Gregorian calendar, leap years have the following rules:

  • A leap year that can be divided by 400 is a leap year.
  • A leap year is also a divisible year by 4 and cannot be divisible by 100.
  • Other years are normal years.

We pass the followingleap()Functions to determine whether a given year is a leap year:

bool leap(int y) {
    return y % 400 == 0 || (y % 4 == 0 && y % 100 != 0);
}

However, different rules may appear for the processing of past dates. First, the Gregorian calendar did not come into effect since 1582. In earlier Julian calendars, every 4 years was set as a leap year, regardless of whether the year could be divisible by 100, nor was it considered whether it could be divisible by 400. So 1500 is also a leap year.

In addition, the Julian calendar has been used since 45 BC and does not exist in 0 years (the next year of “1 BC” is “1 BC”). So is 1 BC a normal year or a leap year? According to the law that 4 years is a leap year.1st BC、5 BC、9 BCIt is a leap year.

However, because the monks at that time misunderstood that "a leap year is set every three years", they set a leap year every three years. In order to correct the error of excessive leap years above, Augustus canceled the three leap years between 12 years and planned to make up for the accumulated error. Only then did the original design of the Julius calendar have a leap year every four years. This means that there was a period from 45 BC to leap year after AD. However, it is no longer possible to test which year is a normal year or a leap year here.

For simplicity, this code assumes to begin on January 1, 1600. These situations are not considered.

Days in a certain month

Different months have different days: July and before, odd months have 31 days and even months have 30 days; after July, odd months have 30 days and even months have 31 days, February is processed separately, with 28 days in the average year and 29 days more in the leap year.

static const int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30};

 int day(int y, int m) {
     return days[m] + (m == 2 && leap(y)); // In a leap year, February is 29 days
 }

Before the reform of the Gregorian calendar, most parts of Europe used the Julian calendar, and this calendar system had a problem: there was a deviation of about 11 minutes per year (Julian calendar years were 11 minutes older than the actual sun). Over time, this deviation accumulates, resulting in the season and date no longer aligned.

To correct this problem, the 10 days before October 15, 1582 (the date of implementation of the Gregorian calendar reform) were "skipped", that is, from October 4 to October 15, thus restoring the correct alignment of the seasons. This has been used to this day, which has resulted in only 21 days in October 1582. However, most date libraries do not consider this by default. This feature may exist in some advanced libraries, and this code does not consider this situation.

Convert date to days

To facilitate calculation of the difference in the number of days between dates, we need to convert the date to the total number of days from January 1, 1600 to the specified date.

static const int days_sum[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
int to_days(const Date &date) {
    auto [y, m, d] = date;
    return 365 * (y - 1600) + (y - 1600 + 3) / 4 - (y - 1600 + 99) / 100 + (y - 1600 + 399) / 400
           + days_sum[m - 1] + d - 1 + (m > 2 && leap(y));
}

Let's parse this function in detail:

  1. calculate\([1600, y)\)The sum of days in each year：

    • 365 * (y - 1600)Calculate the base number of days (365 days per year) for all years from 1600 to the specified year.
    • (y - 1600 + 3) / 4calculate\(4n\)The number of years, they are leap years, each leap year has 1 extra day.
    • (y - 1600 + 99) / 100calculate\(100n\)The number of years, these years are flat, they are also 4 times, but should not be added for 1 day.
    • (y - 1600 + 399) / 400calculate\(400n\)The number of years, these are leap years, they are also multiples of 100, but should be added for 1 day.

  2. calculate\(y-01-01\)arrive\(y-m-d\)Days：

    • days_sum[m - 1]Provides the sum of days for all months [1, m) $.days_sumis an array that stores the accumulated number of days each month ago.
    • d - 1That is, the number of days of this month is the date of the current month minus 1, because we\(1600-01-01\)It is day 0.

  3. Processing for additional days in February：

    • (m > 2 && leap(y))If the month is greater than 2 and the current year is a leap year, then add 1 day after February (February 29).
<Previous Next>