Là std :: chrono :: năm lưu trữ thực sự ít nhất 17 bit?

Từ cppreference

std::chrono::years (since C++20) duration</*signed integer type of at least 17 bits*/, std::ratio<31556952>>

Sử dụng libc++, có vẻ như việc lưu trữ nhấn mạnh của std::chrono::yearslà shortcó chữ ký 16 bit .

std::chrono::years( 30797 )        // yields  32767/01/01
std::chrono::years( 30797 ) + 365d // yields -32768/01/01 apparently UB

Có một lỗi đánh máy trên cppreference hoặc bất cứ điều gì khác?

Thí dụ:

#include <fmt/format.h>
#include <chrono>

template <>
struct fmt::formatter<std::chrono::year_month_day> {
  char presentation = 'F';

  constexpr auto parse(format_parse_context& ctx) {
    auto it = ctx.begin(), end = ctx.end();
    if (it != end && *it == 'F') presentation = *it++;

#   ifdef __exception
    if (it != end && *it != '}') {
      throw format_error("invalid format");
    }
#   endif

    return it;
  }

  template <typename FormatContext>
  auto format(const std::chrono::year_month_day& ymd, FormatContext& ctx) {
    int year(ymd.year() );
    unsigned month(ymd.month() );
    unsigned day(ymd.day() );
    return format_to(
        ctx.out(),
        "{:#6}/{:#02}/{:#02}",
        year, month, day);
  }
};

using days = std::chrono::duration<int32_t, std::ratio<86400> >;
using sys_day = std::chrono::time_point<std::chrono::system_clock, std::chrono::duration<int32_t, std::ratio<86400> >>;

template<typename D>
using sys_time = std::chrono::time_point<std::chrono::system_clock, D>;
using sys_day2 = sys_time<days>;

int main()
{
  auto a = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::hours( (1<<23) - 1 ) 
      )
    )
  );

  auto b = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::minutes( (1l<<29) - 1 ) 
      )
    )
  );

  auto c = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::seconds( (1l<<35) - 1 ) 
      )
    )
  );

  auto e = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::days( (1<<25) - 1 ) 
      )
    )
  );

  auto f = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::weeks( (1<<22) - 1 ) 
      )
    )
  );

  auto g = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::months( (1<<20) - 1 ) 
      )
    )
  );

  auto h = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::years( 30797 ) // 0x7FFF - 1970
      )
    )
  );

  auto i = std::chrono::year_month_day( 
    sys_day( 
      std::chrono::floor<days>(
        std::chrono::years( 30797 ) // 0x7FFF - 1970
      ) + std::chrono::days(365)
    )
  );

  fmt::print("Calendar limit by duration's underlining storage:\n"
             "23 bit hour       : {:F}\n"
             "29 bit minute     : {:F}\n"
             "35 bit second     : {:F}\n"
             "25 bit days       : {:F}\n"
             "22 bit week       : {:F}\n"
             "20 bit month      : {:F}\n"
             "16? bit year      : {:F}\n"
             "16? bit year+365d : {:F}\n"
             , a, b, c, e, f, g, h, i);
}

[ Liên kết Godbolt ]

Bài viết cppreference là chính xác . Nếu libc ++ sử dụng loại nhỏ hơn thì đây có vẻ là một lỗi trong libc ++.

Tôi đang chia nhỏ ví dụ tại https://godbolt.org/z/SNivyp từng mảnh:

  auto a = std::chrono::year_month_day( 
    sys_days( 
      std::chrono::floor<days>(
        std::chrono::years(0) 
        + std::chrono::days( 365 )
      )
    )
  );

Đơn giản hóa và giả định using namespace std::chronolà trong phạm vi:

year_month_day a = sys_days{floor<days>(years{0} + days{365})};

Tiểu biểu years{0}là một durationvới một periodbằng ratio<31'556'952>và một giá trị tương đương để 0. Lưu ý rằng years{1}, được biểu thị dưới dạng dấu phẩy động days, chính xác là 365.2425. Đây là độ dài trung bình của năm dân sự.

Tiểu biểu days{365}là một durationvới một periodbằng ratio<86'400>và một giá trị tương đương để 365.

Tiểu biểu years{0} + days{365}là một durationvới một periodbằng ratio<216>và một giá trị tương đương để 146'000. Này được hình thành bởi việc tìm kiếm đầu tiên common_type_tcủa ratio<31'556'952>và ratio<86'400>là GCD (31'556'952, 86'400), hoặc 216. Thư viện cải đầu tiên cả hai toán hạng cho đơn vị phổ biến này, và sau đó thực hiện việc bổ sung trong đơn vị thông thường.

Để chuyển đổi years{0}thành các đơn vị có thời gian là 216, người ta phải nhân 0 với 146'097. Điều này xảy ra là một điểm rất quan trọng. Chuyển đổi này có thể dễ dàng gây ra tràn khi chỉ thực hiện với 32 bit.

<sang một bên>

Nếu tại thời điểm này bạn cảm thấy bối rối, đó là bởi vì mã có thể có ý định tính toán theo lịch , nhưng thực sự đang thực hiện một tính toán theo thời gian . Tính toán lịch là tính toán với lịch.

Lịch có tất cả các loại bất thường, chẳng hạn như tháng và năm có độ dài vật lý khác nhau về ngày. Một tính toán lịch có tính đến những bất thường này.

Một tính toán theo thời gian làm việc với các đơn vị cố định, và chỉ cần chỉnh các số mà không liên quan đến lịch. Một tính toán theo thời gian không quan tâm nếu bạn sử dụng lịch Gregorian, lịch Julian, lịch Hindu, lịch Trung Quốc, v.v.

</ sang một bên>

Tiếp theo chúng ta mất của chúng tôi 146000[216]sthời gian và chuyển nó sang một thời gian với một periodsố ratio<86'400>(trong đó có một kiểu bí danh tên days). Hàm floor<days>()thực hiện chuyển đổi này và kết quả là 365[86400]s, hoặc đơn giản hơn, chỉ 365d.

Bước tiếp theo lấy durationvà chuyển đổi nó thành a time_point. Các loại time_pointlà time_point<system_clock, days>trong đó có một kiểu bí danh tên sys_days. Đây chỉ đơn giản là số đếm dayskể từ system_clockkỷ nguyên, đó là 1970-01-01 00:00:00 UTC, không bao gồm giây nhuận.

Cuối cùng, sys_daysđược chuyển đổi thành a year_month_dayvới giá trị 1971-01-01.

Một cách đơn giản hơn để thực hiện tính toán này là:

year_month_day a = sys_days{} + days{365};

Hãy xem xét tính toán tương tự này:

year_month_day j = sys_days{floor<days>(years{14699} + days{0})};

Kết quả này trong ngày 16668-12-31. Đó có lẽ là một ngày sớm hơn bạn mong đợi ((14699 + 1970) -01-01). Hiện years{14699} + days{0}tại phụ là : 2'147'479'803[216]s. Lưu ý rằng giá trị thời gian chạy gần INT_MAX( 2'147'483'647) và cơ sở repcủa cả hai yearsvà dayslà int.

Thật vậy, nếu bạn chuyển đổi years{14700}sang các đơn vị của [216]sbạn bị tràn : -2'147'341'396[216]s.

Để khắc phục điều này, hãy chuyển sang tính toán theo lịch:

year_month_day j = (1970y + years{14700})/1/1;

Tất cả các kết quả tại https://godbolt.org/z/SNivyp được thêm yearsvà daysvà sử dụng một giá trị cho yearsrằng lớn hơn 14.699 đang gặp inttràn.

Nếu một người thực sự muốn thực hiện các tính toán theo thời gian yearsvà daystheo cách này, thì sẽ là khôn ngoan khi sử dụng số học 64 bit. Điều này có thể được thực hiện bằng cách chuyển đổi yearssang các đơn vị có repsử dụng sớm hơn 32 bit trong tính toán. Ví dụ:

years{14700} + 0s + days{0}

Bằng cách thêm 0svào years, ( secondsphải có ít nhất 35 bit), sau đó common_type repđược buộc thành 64 bit cho lần thêm đầu tiên ( years{14700} + 0s) và tiếp tục trong 64 bit khi thêm days{0}:

463'887'194'400s == 14700 * 365.2425 * 86400

Tuy nhiên, một cách khác để tránh tràn trung gian (ở cự ly này) là để cắt ngắn yearsđể dayschính xác trước khi bổ sung thêm days:

year_month_day j = sys_days{floor<days>(years{14700})} + days{0};

jcó giá trị 16669-12-31. Điều này tránh được vấn đề bởi vì bây giờ [216]sđơn vị không bao giờ được tạo ra ở nơi đầu tiên. Và chúng tôi thậm chí không bao giờ đến gần giới hạn cho years, dayshoặc year.

Mặc dù nếu bạn đang mong đợi 16700-01-01, thì bạn vẫn có một vấn đề, và cách để khắc phục nó là thực hiện một phép tính theo lịch thay thế:

year_month_day j = (1970y + years{14700})/1/1;