Difference between revisions of "cpp/header/chrono"

Latest revision as of 07:21, 27 November 2023

This header is part of the date and time library.

Functions
Duration
Defined in namespace `std::chrono`
operator+operator-operator*operator/operator% (C++11)	implements arithmetic operations with durations as arguments (function template) [edit]
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(removed in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)	compares two durations (function template) [edit]
duration_cast (C++11)	converts a duration to another, with a different tick interval (function template) [edit]
floor(std::chrono::duration) (C++17)	converts a duration to another, rounding down (function template) [edit]
ceil(std::chrono::duration) (C++17)	converts a duration to another, rounding up (function template) [edit]
round(std::chrono::duration) (C++17)	converts a duration to another, rounding to nearest, ties to even (function template) [edit]
abs(std::chrono::duration) (C++17)	obtains the absolute value of the duration (function template) [edit]
Time point
Defined in namespace `std::chrono`
operator+operator- (C++11)	performs add and subtract operations involving a time point (function template) [edit]
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(removed in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)	compares two time points (function template) [edit]
time_point_cast (C++11)	converts a time point to another time point on the same clock, with a different duration (function template) [edit]
floor(std::chrono::time_point) (C++17)	converts a time_point to another, rounding down (function template) [edit]
ceil(std::chrono::time_point) (C++17)	converts a time_point to another, rounding up (function template) [edit]
round(std::chrono::time_point) (C++17)	converts a time_point to another, rounding to nearest, ties to even (function template) [edit]
from_stream(std::chrono::sys_time) (C++20)	parses a `sys_time` from a stream according to the provided format (function template) [edit]
from_stream(std::chrono::utc_time) (C++20)	parses a `utc_time` from a stream according to the provided format (function template) [edit]
from_stream(std::chrono::tai_time) (C++20)	parses a `tai_time` from a stream according to the provided format (function template) [edit]
from_stream(std::chrono::gps_time) (C++20)	parses a `gps_time` from a stream according to the provided format (function template) [edit]
from_stream(std::chrono::file_time) (C++20)	parses a `file_time` from a stream according to the provided format (function template) [edit]
from_stream(std::chrono::local_time) (C++20)	parses a `local_time` from a stream according to the provided format (function template) [edit]
clock_cast (C++20)	convert time points of one clock to another (function template) [edit]
Calendar
Defined in namespace `std::chrono`
operator==operator<=> (C++20)	compares two `day` values (function) [edit]
operator==operator<=> (C++20)	compares two `month` values (function) [edit]
operator==operator<=> (C++20)	compares two `year` values (function) [edit]
operator== (C++20)	compares two `weekday` values (function) [edit]
operator== (C++20)	compares two `weekday_indexed` values (function) [edit]
operator== (C++20)	compares two `weekday_last` values (function) [edit]
operator==operator<=> (C++20)	compares two `month_day` values (function) [edit]
operator==operator<=> (C++20)	compares two `month_day_last` values (function) [edit]
operator== (C++20)	compares two `month_weekday` values (function) [edit]
operator== (C++20)	compares two `month_weekday_last` values (function) [edit]
operator==operator<=> (C++20)	compares two `year_month` values (function) [edit]
operator==operator<=> (C++20)	compares two `year_month_day` values (function) [edit]
operator==operator<=> (C++20)	compares two `year_month_day_last` values (function) [edit]
operator== (C++20)	compares two `year_month_weekday` values (function) [edit]
operator== (C++20)	compares two `year_month_weekday_last` values (function) [edit]
operator+operator- (C++20)	adds or subtracts a number of days and a `day`, or find the difference between two `day`s (function) [edit]
operator+operator- (C++20)	performs arithmetic on `month`s (function) [edit]
operator+operator- (C++20)	performs arithmetic on `year`s (function) [edit]
operator+operator- (C++20)	performs arithmetic on `weekday`s (function) [edit]
operator+operator- (C++20)	performs arithmetic on `year_month` (function) [edit]
operator+operator- (C++20)	adds or subtracts a `year_month_day` and some number of years or months (function) [edit]
operator+operator- (C++20)	adds or subtracts a `year_month_day_last` and some number of years or months (function) [edit]
operator+operator- (C++20)	adds or subtracts a `year_month_weekday` and some number of years or months (function) [edit]
operator+operator- (C++20)	adds or subtracts a `year_month_weekday_last` and some number of years or months (function) [edit]
operator/ (C++20)	conventional syntax for Gregorian calendar date creation (function) [edit]
Time of day
Defined in namespace `std::chrono`
is_amis_pmmake12make24 (C++20)	translates between a 12h/24h format time of day (function) [edit]
Time zone
Defined in namespace `std::chrono`
get_tzdbget_tzdb_listreload_tzdbremote_version (C++20)	accesses and controls the global time zone database information (function) [edit]
locate_zone (C++20)	locates a `time_zone` based on its name (function) [edit]
operator==operator<=> (C++20)	compares two `time_zone` objects (function) [edit]
operator== (C++20)	compares two `zoned_time` values (function template) [edit]
operator==operator<=> (C++20)	compares two `time_zone_link` objects (function) [edit]
Leap second
Defined in namespace `std::chrono`
get_leap_second_info (C++20)	obtains leap second insertion information from a `utc_time` object (function template) [edit]
operator==operator<operator<=operator>operator>=operator<=> (C++20)	compares two `leap_second` values or a `leap_second` value and a sys_time (function template) [edit]
I/O
Defined in namespace `std::chrono`
operator<< (C++20)	performs stream output on a `duration` (function template) [edit]
operator<<(std::chrono::sys_time) (C++20)	performs stream output on a `sys_time` (function template) [edit]
operator<<(std::chrono::utc_time) (C++20)	performs stream output on a `utc_time` (function template) [edit]
operator<<(std::chrono::tai_time) (C++20)	performs stream output on a `tai_time` (function template) [edit]
operator<<(std::chrono::gps_time) (C++20)	performs stream output on a `gps_time` (function template) [edit]
operator<<(std::chrono::file_time) (C++20)	performs stream output on a `file_time` (function template) [edit]
operator<< (C++20)	outputs a `day` into a stream (function template) [edit]
operator<< (C++20)	outputs a `month` into a stream (function template) [edit]
operator<< (C++20)	outputs a `year` into a stream (function template) [edit]
operator<< (C++20)	outputs a `weekday` into a stream (function template) [edit]
operator<< (C++20)	outputs a `weekday_indexed` into a stream (function template) [edit]
operator<< (C++20)	outputs a `weekday_last` into a stream (function template) [edit]
operator<< (C++20)	outputs a `month_day` into a stream (function template) [edit]
operator<< (C++20)	outputs a `month_day_last` into a stream (function template) [edit]
operator<< (C++20)	outputs a `month_weekday` into a stream (function template) [edit]
operator<< (C++20)	outputs a `month_weekday_last` into a stream (function template) [edit]
operator<< (C++20)	outputs a `year_month` into a stream (function template) [edit]
operator<< (C++20)	outputs a `year_month_day` into a stream (function template) [edit]
operator<< (C++20)	outputs a `year_month_day_last` into a stream (function template) [edit]
operator<< (C++20)	outputs a `year_month_weekday` into a stream (function template) [edit]
operator<< (C++20)	outputs a `year_month_weekday_last` into a stream (function template) [edit]
operator<< (C++20)	outputs a `hh_mm_ss` into a stream (function template) [edit]
operator<< (C++20)	outputs a `sys_info` into a stream (function template) [edit]
operator<< (C++20)	outputs a `local_info` into a stream (function template) [edit]
operator<< (C++20)	outputs a `zoned_time` into a stream (function template) [edit]
from_stream (C++20)	parses a `day` from a stream according to the provided format (function template) [edit]
from_stream (C++20)	parses a `month` from a stream according to the provided format (function template) [edit]
from_stream (C++20)	parses a `year` from a stream according to the provided format (function template) [edit]
from_stream (C++20)	parses a `weekday` from a stream according to the provided format (function template) [edit]
from_stream (C++20)	parses a `month_day` from a stream according to the provided format (function template) [edit]
from_stream (C++20)	parses a `year_month` from a stream according to the provided format (function template) [edit]
from_stream (C++20)	parses a `year_month_day` from a stream according to the provided format (function template) [edit]
parse (C++20)	parses a `chrono` object from a stream (function template) [edit]
Literals
Defined in inline namespace `std::literals::chrono_literals`
operator""h (C++14)	a std::chrono::duration literal representing hours (function) [edit]
operator""min (C++14)	a std::chrono::duration literal representing minutes (function) [edit]
operator""s (C++14)	a std::chrono::duration literal representing seconds (function) [edit]
operator""ms (C++14)	a std::chrono::duration literal representing milliseconds (function) [edit]
operator""us (C++14)	a std::chrono::duration literal representing microseconds (function) [edit]
operator""ns (C++14)	a std::chrono::duration literal representing nanoseconds (function) [edit]
operator""d (C++20)	a std::chrono::day literal representing a day of a month (function) [edit]
operator""y (C++20)	a std::chrono::year literal representing a particular year (function) [edit]

[edit] Synopsis

#include <compare>
 
namespace std {
  namespace chrono {
    // class template duration
    template<class Rep, class Period = ratio<1>> class duration;
 
    // class template time_point
    template<class Clock, class Duration = typename Clock::duration> class time_point;
  }
 
  // common_type specializations
  template<class Rep1, class Period1, class Rep2, class Period2>
    struct common_type<chrono::duration<Rep1, Period1>,
                       chrono::duration<Rep2, Period2>>;
 
  template<class Clock, class Duration1, class Duration2>
    struct common_type<chrono::time_point<Clock, Duration1>,
                       chrono::time_point<Clock, Duration2>>;
 
  namespace chrono {
    // customization traits
    template<class Rep> struct treat_as_floating_point;
    template<class Rep>
      inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;
 
    template<class Rep> struct duration_values;
 
    template<class T> struct is_clock;
    template<class T> inline constexpr bool is_clock_v = is_clock<T>::value;
 
    // duration arithmetic
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
        operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
        operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period, class Rep2>
      constexpr duration<common_type_t<Rep1, Rep2>, Period>
        operator*(const duration<Rep1, Period>& d, const Rep2& s);
    template<class Rep1, class Rep2, class Period>
      constexpr duration<common_type_t<Rep1, Rep2>, Period>
        operator*(const Rep1& s, const duration<Rep2, Period>& d);
    template<class Rep1, class Period, class Rep2>
      constexpr duration<common_type_t<Rep1, Rep2>, Period>
        operator/(const duration<Rep1, Period>& d, const Rep2& s);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr common_type_t<Rep1, Rep2>
        operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period, class Rep2>
      constexpr duration<common_type_t<Rep1, Rep2>, Period>
        operator%(const duration<Rep1, Period>& d, const Rep2& s);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
        operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 
    // duration comparisons
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator==(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator< (const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator> (const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Rep2, class Period2>
      requires /* see description */
      constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
                                 const duration<Rep2, Period2>& rhs);
 
    // conversions
    template<class ToDuration, class Rep, class Period>
      constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
    template<class ToDuration, class Rep, class Period>
      constexpr ToDuration floor(const duration<Rep, Period>& d);
    template<class ToDuration, class Rep, class Period>
      constexpr ToDuration ceil(const duration<Rep, Period>& d);
    template<class ToDuration, class Rep, class Period>
      constexpr ToDuration round(const duration<Rep, Period>& d);
 
    // duration I/O
    template<class CharT, class Traits, class Rep, class Period>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os,
                   const duration<Rep, Period>& d);
    template<class CharT, class Traits, class Rep, class Period, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    duration<Rep, Period>& d,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // convenience typedefs
    using nanoseconds  = duration</* signed integer type of at least 64 bits */, nano>;
    using microseconds = duration</* signed integer type of at least 55 bits */, micro>;
    using milliseconds = duration</* signed integer type of at least 45 bits */, milli>;
    using seconds      = duration</* signed integer type of at least 35 bits */>;
    using minutes      = duration</* signed integer type of at least 29 bits */,
                                  ratio<  60>>;
    using hours        = duration</* signed integer type of at least 23 bits */,
                                  ratio<3600>>;
    using days         = duration</* signed integer type of at least 25 bits */,
                                  ratio_multiply<ratio<24>, hours::period>>;
    using weeks        = duration</* signed integer type of at least 22 bits */,
                                  ratio_multiply<ratio<7>, days::period>>;
    using years        = duration</* signed integer type of at least 17 bits */,
                                  ratio_multiply<ratio<146097, 400>, days::period>>;
    using months       = duration</* signed integer type of at least 20 bits */,
                                  ratio_divide<years::period, ratio<12>>>;
 
    // time_point arithmetic
    template<class Clock, class Duration1, class Rep2, class Period2>
      constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
        operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
    template<class Rep1, class Period1, class Clock, class Duration2>
      constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
        operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
    template<class Clock, class Duration1, class Rep2, class Period2>
      constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
        operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
    template<class Clock, class Duration1, class Duration2>
      constexpr common_type_t<Duration1, Duration2>
        operator-(const time_point<Clock, Duration1>& lhs,
                  const time_point<Clock, Duration2>& rhs);
 
    // time_point comparisons
    template<class Clock, class Duration1, class Duration2>
       constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template<class Clock, class Duration1, class Duration2>
       constexpr bool operator< (const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template<class Clock, class Duration1, class Duration2>
       constexpr bool operator> (const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template<class Clock, class Duration1, class Duration2>
       constexpr bool operator<=(const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template<class Clock, class Duration1, class Duration2>
       constexpr bool operator>=(const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template<class Clock, class Duration1, three_way_comparable_with<Duration1> Duration2>
       constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
                                  const time_point<Clock, Duration2>& rhs);
 
    // conversions
    template<class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration>
        time_point_cast(const time_point<Clock, Duration>& t);
    template<class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration> floor(const time_point<Clock, Duration>& tp);
    template<class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration> ceil(const time_point<Clock, Duration>& tp);
    template<class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration> round(const time_point<Clock, Duration>& tp);
 
    // specialized algorithms
    template<class Rep, class Period>
      constexpr duration<Rep, Period> abs(duration<Rep, Period> d);
 
    // class system_clock
    class system_clock;
 
    template<class Duration>
      using sys_time  = time_point<system_clock, Duration>;
    using sys_seconds = sys_time<seconds>;
    using sys_days    = sys_time<days>;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const sys_time<Duration>& tp);
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const sys_days& dp);
 
    template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    sys_time<Duration>& tp,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class utc_clock
    class utc_clock;
 
    template<class Duration>
      using utc_time  = time_point<utc_clock, Duration>;
    using utc_seconds = utc_time<seconds>;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const utc_time<Duration>& t);
    template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    utc_time<Duration>& tp,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    struct leap_second_info;
 
    template<class Duration>
      leap_second_info get_leap_second_info(const utc_time<Duration>& ut);
 
    // class tai_clock
    class tai_clock;
 
    template<class Duration>
      using tai_time  = time_point<tai_clock, Duration>;
    using tai_seconds = tai_time<seconds>;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const tai_time<Duration>& t);
    template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    tai_time<Duration>& tp,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class gps_clock
    class gps_clock;
 
    template<class Duration>
      using gps_time  = time_point<gps_clock, Duration>;
    using gps_seconds = gps_time<seconds>;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const gps_time<Duration>& t);
    template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    gps_time<Duration>& tp,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // type file_clock
    using file_clock = /* see description */;
 
    template<class Duration>
      using file_time = time_point<file_clock, Duration>;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const file_time<Duration>& tp);
    template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    file_time<Duration>& tp,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class steady_clock
    class steady_clock;
 
    // class high_resolution_clock
    class high_resolution_clock;
 
    // local time
    struct local_t {};
    template<class Duration>
      using local_time  = time_point<local_t, Duration>;
    using local_seconds = local_time<seconds>;
    using local_days    = local_time<days>;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const local_time<Duration>& tp);
    template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    local_time<Duration>& tp,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // time_point conversions
    template<class DestClock, class SourceClock>
      struct clock_time_conversion;
 
    template<class DestClock, class SourceClock, class Duration>
      auto clock_cast(const time_point<SourceClock, Duration>& t);
 
    // class last_spec
    struct last_spec;
 
    // class day
    class day;
 
    constexpr bool operator==(const day& x, const day& y) noexcept;
    constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
 
    constexpr day  operator+(const day&  x, const days& y) noexcept;
    constexpr day  operator+(const days& x, const day&  y) noexcept;
    constexpr day  operator-(const day&  x, const days& y) noexcept;
    constexpr days operator-(const day&  x, const day&  y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const day& d);
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    day& d, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class month
    class month;
 
    constexpr bool operator==(const month& x, const month& y) noexcept;
    constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
 
    constexpr month  operator+(const month&  x, const months& y) noexcept;
    constexpr month  operator+(const months& x,  const month& y) noexcept;
    constexpr month  operator-(const month&  x, const months& y) noexcept;
    constexpr months operator-(const month&  x,  const month& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const month& m);
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    month& m, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class year
    class year;
 
    constexpr bool operator==(const year& x, const year& y) noexcept;
    constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
 
    constexpr year  operator+(const year&  x, const years& y) noexcept;
    constexpr year  operator+(const years& x, const year&  y) noexcept;
    constexpr year  operator-(const year&  x, const years& y) noexcept;
    constexpr years operator-(const year&  x, const year&  y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const year& y);
 
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    year& y, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class weekday
    class weekday;
 
    constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
 
    constexpr weekday operator+(const weekday& x, const days&    y) noexcept;
    constexpr weekday operator+(const days&    x, const weekday& y) noexcept;
    constexpr weekday operator-(const weekday& x, const days&    y) noexcept;
    constexpr days    operator-(const weekday& x, const weekday& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const weekday& wd);
 
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    weekday& wd, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class weekday_indexed
    class weekday_indexed;
 
    constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi);
 
    // class weekday_last
    class weekday_last;
 
    constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const weekday_last& wdl);
 
    // class month_day
    class month_day;
 
    constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
    constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const month_day& md);
 
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    month_day& md, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class month_day_last
    class month_day_last;
 
    constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
    constexpr strong_ordering operator<=>(const month_day_last& x,
                                          const month_day_last& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const month_day_last& mdl);
 
    // class month_weekday
    class month_weekday;
 
    constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const month_weekday& mwd);
 
    // class month_weekday_last
    class month_weekday_last;
 
    constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl);
 
    // class year_month
    class year_month;
 
    constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
    constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
 
    constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
    constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
    constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
    constexpr months operator-(const year_month& x, const year_month& y) noexcept;
    constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
    constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
    constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const year_month& ym);
 
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    year_month& ym, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class year_month_day
    class year_month_day;
 
    constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
    constexpr strong_ordering operator<=>(const year_month_day& x,
                                          const year_month_day& y) noexcept;
 
    constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
    constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
    constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
    constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
    constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
    constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const year_month_day& ymd);
 
    template<class CharT, class Traits, class Alloc = allocator<CharT>>
      basic_istream<CharT, Traits>&
        from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
                    year_month_day& ymd,
                    basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
                    minutes* offset = nullptr);
 
    // class year_month_day_last
    class year_month_day_last;
 
    constexpr bool operator==(const year_month_day_last& x,
                              const year_month_day_last& y) noexcept;
    constexpr strong_ordering operator<=>(const year_month_day_last& x,
                                          const year_month_day_last& y) noexcept;
 
    constexpr year_month_day_last
      operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
    constexpr year_month_day_last
      operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
    constexpr year_month_day_last
      operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
    constexpr year_month_day_last
      operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
    constexpr year_month_day_last
      operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
    constexpr year_month_day_last
      operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl);
 
    // class year_month_weekday
    class year_month_weekday;
 
    constexpr bool operator==(const year_month_weekday& x,
                              const year_month_weekday& y) noexcept;
 
    constexpr year_month_weekday
      operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
    constexpr year_month_weekday
      operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
    constexpr year_month_weekday
      operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
    constexpr year_month_weekday
      operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
    constexpr year_month_weekday
      operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
    constexpr year_month_weekday
      operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwdi);
 
    // class year_month_weekday_last
    class year_month_weekday_last;
 
    constexpr bool operator==(const year_month_weekday_last& x,
                              const year_month_weekday_last& y) noexcept;
 
    constexpr year_month_weekday_last
      operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
    constexpr year_month_weekday_last
      operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
    constexpr year_month_weekday_last
      operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
    constexpr year_month_weekday_last
      operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
    constexpr year_month_weekday_last
      operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
    constexpr year_month_weekday_last
      operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
 
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl);
 
    // civil calendar conventional syntax operators
    constexpr year_month
      operator/(const year& y, const month& m) noexcept;
    constexpr year_month
      operator/(const year& y, int m) noexcept;
    constexpr month_day
      operator/(const month& m, const day& d) noexcept;
    constexpr month_day
      operator/(const month& m, int d) noexcept;
    constexpr month_day
      operator/(int m, const day& d) noexcept;
    constexpr month_day
      operator/(const day& d, const month& m) noexcept;
    constexpr month_day
      operator/(const day& d, int m) noexcept;
    constexpr month_day_last
      operator/(const month& m, last_spec) noexcept;
    constexpr month_day_last
      operator/(int m, last_spec) noexcept;
    constexpr month_day_last
      operator/(last_spec, const month& m) noexcept;
    constexpr month_day_last
      operator/(last_spec, int m) noexcept;
    constexpr month_weekday
      operator/(const month& m, const weekday_indexed& wdi) noexcept;
    constexpr month_weekday
      operator/(int m, const weekday_indexed& wdi) noexcept;
    constexpr month_weekday
      operator/(const weekday_indexed& wdi, const month& m) noexcept;
    constexpr month_weekday
      operator/(const weekday_indexed& wdi, int m) noexcept;
    constexpr month_weekday_last
      operator/(const month& m, const weekday_last& wdl) noexcept;
    constexpr month_weekday_last
      operator/(int m, const weekday_last& wdl) noexcept;
    constexpr month_weekday_last
      operator/(const weekday_last& wdl, const month& m) noexcept;
    constexpr month_weekday_last
      operator/(const weekday_last& wdl, int m) noexcept;
    constexpr year_month_day
      operator/(const year_month& ym, const day& d) noexcept;
    constexpr year_month_day
      operator/(const year_month& ym, int d) noexcept;
    constexpr year_month_day
      operator/(const year& y, const month_day& md) noexcept;
    constexpr year_month_day
      operator/(int y, const month_day& md) noexcept;
    constexpr year_month_day
      operator/(const month_day& md, const year& y) noexcept;
    constexpr year_month_day
      operator/(const month_day& md, int y) noexcept;
    constexpr year_month_day_last
      operator/(const year_month& ym, last_spec) noexcept;
    constexpr year_month_day_last
      operator/(const year& y, const month_day_last& mdl) noexcept;
    constexpr year_month_day_last
      operator/(int y, const month_day_last& mdl) noexcept;
    constexpr year_month_day_last
      operator/(const month_day_last& mdl, const year& y) noexcept;
    constexpr year_month_day_last
      operator/(const month_day_last& mdl, int y) noexcept;
    constexpr year_month_weekday
      operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
    constexpr year_month_weekday
      operator/(const year& y, const month_weekday& mwd) noexcept;
    constexpr year_month_weekday
      operator/(int y, const month_weekday& mwd) noexcept;
    constexpr year_month_weekday
      operator/(const month_weekday& mwd, const year& y) noexcept;
    constexpr year_month_weekday
      operator/(const month_weekday& mwd, int y) noexcept;
    constexpr year_month_weekday_last
      operator/(const year_month& ym, const weekday_last& wdl) noexcept;
    constexpr year_month_weekday_last
      operator/(const year& y, const month_weekday_last& mwdl) noexcept;
    constexpr year_month_weekday_last
      operator/(int y, const month_weekday_last& mwdl) noexcept;
    constexpr year_month_weekday_last
      operator/(const month_weekday_last& mwdl, const year& y) noexcept;
    constexpr year_month_weekday_last
      operator/(const month_weekday_last& mwdl, int y) noexcept;
 
    // class template hh_mm_ss
    template<class Duration> class hh_mm_ss;
 
    template<class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const hh_mm_ss<Duration>& hms);
 
    // 12/24 hour functions
    constexpr bool is_am(const hours& h) noexcept;
    constexpr bool is_pm(const hours& h) noexcept;
    constexpr hours make12(const hours& h) noexcept;
    constexpr hours make24(const hours& h, bool is_pm) noexcept;
 
    // time zone database
    struct tzdb;
    class tzdb_list;
 
    // time zone database access
    const tzdb& get_tzdb();
    tzdb_list& get_tzdb_list();
    const time_zone* locate_zone(string_view tz_name);
    const time_zone* current_zone();
 
    // remote time zone database support
    const tzdb& reload_tzdb();
    string remote_version();
 
    // exception classes
    class nonexistent_local_time;
    class ambiguous_local_time;
 
    // information classes
    struct sys_info;
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const sys_info& si);
 
    struct local_info;
    template<class CharT, class Traits>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os, const local_info& li);
 
    // class time_zone
    enum class choose {earliest, latest};
    class time_zone;
 
    bool operator==(const time_zone& x, const time_zone& y) noexcept;
    strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;
 
    // class template zoned_traits
    template<class T> struct zoned_traits;
 
    // class template zoned_time
    template<class Duration, class TimeZonePtr = const time_zone*> class zoned_time;
 
    using zoned_seconds = zoned_time<seconds>;
 
    template<class Duration1, class Duration2, class TimeZonePtr>
      bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
                      const zoned_time<Duration2, TimeZonePtr>& y);
 
    template<class CharT, class Traits, class Duration, class TimeZonePtr>
      basic_ostream<CharT, Traits>&
        operator<<(basic_ostream<CharT, Traits>& os,
                   const zoned_time<Duration, TimeZonePtr>& t);
 
    // leap second support
    class leap_second;
 
    bool operator==(const leap_second& x, const leap_second& y);
    strong_ordering operator<=>(const leap_second& x, const leap_second& y);
 
    template<class Duration>
      constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
    template<class Duration>
      constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
    template<class Duration>
      constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
    template<class Duration>
      constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
    template<class Duration>
      constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
    template<class Duration>
      constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
    template<class Duration>
      constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
    template<class Duration>
      constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
    template<class Duration>
      constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
    template<class Duration>
      requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
      constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
 
    // class time_zone_link
    class time_zone_link;
 
    bool operator==(const time_zone_link& x, const time_zone_link& y);
    strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y);
 
    // formatting
    template<class Duration> struct /*local-time-format-t*/;    // exposition only
    template<class Duration>
      /*local-time-format-t*/<Duration>
        local_time_format(local_time<Duration> time, const string* abbrev = nullptr,
                          const seconds* offset_sec = nullptr);
  }
 
  template<class Rep, class Period, class CharT>
    struct formatter<chrono::duration<Rep, Period>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::sys_time<Duration>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::utc_time<Duration>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::tai_time<Duration>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::gps_time<Duration>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::file_time<Duration>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::local_time<Duration>, CharT>;
  template<class Duration, class CharT>
    struct formatter<chrono::/*local-time-format-t*/<Duration>, CharT>;
  template<class CharT> struct formatter<chrono::day, CharT>;
  template<class CharT> struct formatter<chrono::month, CharT>;
  template<class CharT> struct formatter<chrono::year, CharT>;
  template<class CharT> struct formatter<chrono::weekday, CharT>;
  template<class CharT> struct formatter<chrono::weekday_indexed, CharT>;
  template<class CharT> struct formatter<chrono::weekday_last, CharT>;
  template<class CharT> struct formatter<chrono::month_day, CharT>;
  template<class CharT> struct formatter<chrono::month_day_last, CharT>;
  template<class CharT> struct formatter<chrono::month_weekday, CharT>;
  template<class CharT> struct formatter<chrono::month_weekday_last, CharT>;
  template<class CharT> struct formatter<chrono::year_month, CharT>;
  template<class CharT> struct formatter<chrono::year_month_day, CharT>;
  template<class CharT> struct formatter<chrono::year_month_day_last, CharT>;
  template<class CharT> struct formatter<chrono::year_month_weekday, CharT>;
  template<class CharT> struct formatter<chrono::year_month_weekday_last, CharT>;
  template<class Rep, class Period, class CharT>
    struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, CharT>;
  template<class CharT> struct formatter<chrono::sys_info, CharT>;
  template<class CharT> struct formatter<chrono::local_info, CharT>;
  template<class Duration, class TimeZonePtr, class CharT>
    struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, CharT>;
 
  namespace chrono {
    // parsing
    template<class CharT, class Parsable>
      /* unspecified */
        parse(const CharT* fmt, Parsable& tp);
 
    template<class CharT, class Traits, class Alloc, class Parsable>
      /* unspecified */
        parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp);
 
    template<class CharT, class traits, class Alloc, class Parsable>
      /* unspecified */
        parse(const CharT* fmt, Parsable& tp,
              basic_string<CharT, traits, Alloc>& abbrev);
 
    template<class CharT, class Traits, class Alloc, class Parsable>
      /* unspecified */
        parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
              basic_string<CharT, Traits, Alloc>& abbrev);
 
    template<class CharT, class Parsable>
      /* unspecified */
        parse(const CharT* fmt, Parsable& tp, minutes& offset);
 
    template<class CharT, class Traits, class Alloc, class Parsable>
      /* unspecified */
        parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
              minutes& offset);
 
    template<class CharT, class traits, class Alloc, class Parsable>
      /* unspecified */
        parse(const CharT* fmt, Parsable& tp,
              basic_string<CharT, traits, Alloc>& abbrev, minutes& offset);
 
    template<class CharT, class Traits, class Alloc, class Parsable>
      /* unspecified */
        parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
              basic_string<CharT, Traits, Alloc>& abbrev, minutes& offset);
 
    // calendrical constants
    inline constexpr last_spec last{};
 
    inline constexpr weekday Sunday{0};
    inline constexpr weekday Monday{1};
    inline constexpr weekday Tuesday{2};
    inline constexpr weekday Wednesday{3};
    inline constexpr weekday Thursday{4};
    inline constexpr weekday Friday{5};
    inline constexpr weekday Saturday{6};
 
    inline constexpr month January{1};
    inline constexpr month February{2};
    inline constexpr month March{3};
    inline constexpr month April{4};
    inline constexpr month May{5};
    inline constexpr month June{6};
    inline constexpr month July{7};
    inline constexpr month August{8};
    inline constexpr month September{9};
    inline constexpr month October{10};
    inline constexpr month November{11};
    inline constexpr month December{12};
  }
 
  inline namespace literals {
  inline namespace chrono_literals {
    // suffixes for duration literals
    constexpr chrono::hours                    operator""h(unsigned long long);
    constexpr chrono::duration</* unspecified */,
                               ratio<3600, 1>> operator""h(long double);
 
    constexpr chrono::minutes                operator""min(unsigned long long);
    constexpr chrono::duration</* unspecified */,
                               ratio<60, 1>> operator""min(long double);
 
    constexpr chrono::seconds                     operator""s(unsigned long long);
    constexpr chrono::duration</* unspecified */> operator""s(long double);
 
    constexpr chrono::milliseconds                       operator""ms(unsigned long long);
    constexpr chrono::duration</* unspecified */, milli> operator""ms(long double);
 
    constexpr chrono::microseconds                       operator""us(unsigned long long);
    constexpr chrono::duration</* unspecified */, micro> operator""us(long double);
 
    constexpr chrono::nanoseconds                       operator""ns(unsigned long long);
    constexpr chrono::duration</* unspecified */, nano> operator""ns(long double);
 
    // non-member functions
    constexpr chrono::day  operator""d(unsigned long long d) noexcept;
 
    // non-member functions
    constexpr chrono::year operator""y(unsigned long long y) noexcept;
  }
  }
 
  namespace chrono {
    using namespace literals::chrono_literals;
  }
 
  // hash support
  template<class T> struct hash;
  template<class Rep, class Period>
    struct hash<chrono::duration<Rep, Period>>;
  template<class Clock, class Duration>
    struct hash<chrono::time_point<Clock, Duration>>;
  template<> struct hash<chrono::day>;
  template<> struct hash<chrono::month>;
  template<> struct hash<chrono::year>;
  template<> struct hash<chrono::weekday>;
  template<> struct hash<chrono::weekday_indexed>;
  template<> struct hash<chrono::weekday_last>;
  template<> struct hash<chrono::month_day>;
  template<> struct hash<chrono::month_day_last>;
  template<> struct hash<chrono::month_weekday>;
  template<> struct hash<chrono::month_weekday_last>;
  template<> struct hash<chrono::year_month>;
  template<> struct hash<chrono::year_month_day>;
  template<> struct hash<chrono::year_month_day_last>;
  template<> struct hash<chrono::year_month_weekday>;
  template<> struct hash<chrono::year_month_weekday_last>;
  template<class Duration, class TimeZonePtr>
    struct hash<chrono::zoned_time<Duration, TimeZonePtr>>;
  template<> struct hash<chrono::leap_second>;
}

[edit] Class template std::chrono::duration

namespace std::chrono {
  template<class Rep, class Period = ratio<1>>
  class duration {
  public:
    using rep    = Rep;
    using period = typename Period::type;
 
  private:
    rep rep_;       // exposition only
 
  public:
    // construct/copy/destroy
    constexpr duration() = default;
    template<class Rep2>
      constexpr explicit duration(const Rep2& r);
    template<class Rep2, class Period2>
      constexpr duration(const duration<Rep2, Period2>& d);
    ~duration() = default;
    duration(const duration&) = default;
    duration& operator=(const duration&) = default;
 
    // observer
    constexpr rep count() const;
 
    // arithmetic
    constexpr common_type_t<duration> operator+() const;
    constexpr common_type_t<duration> operator-() const;
    constexpr duration& operator++();
    constexpr duration  operator++(int);
    constexpr duration& operator--();
    constexpr duration  operator--(int);
 
    constexpr duration& operator+=(const duration& d);
    constexpr duration& operator-=(const duration& d);
 
    constexpr duration& operator*=(const rep& rhs);
    constexpr duration& operator/=(const rep& rhs);
    constexpr duration& operator%=(const rep& rhs);
    constexpr duration& operator%=(const duration& rhs);
 
    // special values
    static constexpr duration zero() noexcept;
    static constexpr duration min() noexcept;
    static constexpr duration max() noexcept;
  };
}

[edit] Class template std::chrono::time_point

namespace std::chrono {
  template<class Clock, class Duration = typename Clock::duration>
  class time_point {
  public:
    using clock    = Clock;
    using duration = Duration;
    using rep      = typename duration::rep;
    using period   = typename duration::period;
 
  private:
    duration d_;                                                // exposition only
 
  public:
    // construct
    constexpr time_point();                                     // has value epoch
    constexpr explicit time_point(const duration& d);           // same as time_point() + d
    template<class Duration2>
      constexpr time_point(const time_point<clock, Duration2>& t);
 
    // observer
    constexpr duration time_since_epoch() const;
 
    // arithmetic
    constexpr time_point& operator++();
    constexpr time_point operator++(int);
    constexpr time_point& operator--();
    constexpr time_point operator--(int);
    constexpr time_point& operator+=(const duration& d);
    constexpr time_point& operator-=(const duration& d);
 
    // special values
    static constexpr time_point min() noexcept;
    static constexpr time_point max() noexcept;
  };
}

[edit] Class template std::common_type's specialization for std::chrono::duration

namespace std {
  template<class Rep1, class Period1, class Rep2, class Period2>
    struct common_type<chrono::duration<Rep1, Period1>,
                       chrono::duration<Rep2, Period2>> {
      using type = chrono::duration<common_type_t<Rep1, Rep2>, /* see description */>;
    };
}

[edit] Class template std::common_type's specialization for std::chrono::time_point

namespace std {
  template<class Clock, class Duration1, class Duration2>
    struct common_type<chrono::time_point<Clock, Duration1>,
                       chrono::time_point<Clock, Duration2>> {
      using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;
    };
}

[edit] Class template std::chrono::treat_as_floating_point

template<class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };

[edit] Class template std::chrono::duration_values

namespace std::chrono {
  template<class Rep>
    struct duration_values {
    public:
      static constexpr Rep zero() noexcept;
      static constexpr Rep min() noexcept;
      static constexpr Rep max() noexcept;
    };
}

[edit] Class std::chrono::system_clock

namespace std::chrono {
  class system_clock {
  public:
    using rep        = /* see description */;
    using period     = ratio</* unspecified */, /* unspecified */>;
    using duration   = chrono::duration<rep, period>;
    using time_point = chrono::time_point<system_clock>;
    static constexpr bool is_steady = /* unspecified */;
 
    static time_point now() noexcept;
 
    // mapping to/from C type time_t
    static time_t      to_time_t  (const time_point& t) noexcept;
    static time_point  from_time_t(time_t t) noexcept;
  };
}

[edit] Class std::chrono::utc_clock

namespace std::chrono {
  class utc_clock {
  public:
    using rep                       = /* a signed arithmetic type */;
    using period                    = ratio</* unspecified */, /* unspecified */>;
    using duration                  = chrono::duration<rep, period>;
    using time_point                = chrono::time_point<utc_clock>;
    static constexpr bool is_steady = /* unspecified */;
 
    static time_point now();
 
    template<class Duration>
      static sys_time<common_type_t<Duration, seconds>>
        to_sys(const utc_time<Duration>& t);
    template<class Duration>
      static utc_time<common_type_t<Duration, seconds>>
        from_sys(const sys_time<Duration>& t);
  };
}

[edit] Class std::chrono::tai_clock

namespace std::chrono {
  class tai_clock {
  public:
    using rep                       = /* a signed arithmetic type */;
    using period                    = ratio</* unspecified */, /* unspecified */>;
    using duration                  = chrono::duration<rep, period>;
    using time_point                = chrono::time_point<tai_clock>;
    static constexpr bool is_steady = /* unspecified */;
 
    static time_point now();
 
    template<class Duration>
      static sys_time<common_type_t<Duration, seconds>>
        to_sys(const tai_time<Duration>& t);
    template<class Duration>
      static tai_time<common_type_t<Duration, seconds>>
        from_sys(const sys_time<Duration>& t);
  };
}

[edit] Class std::chrono::gps_clock

namespace std::chrono {
  class gps_clock {
  public:
    using rep                       = /* a signed arithmetic type */;
    using period                    = ratio</* unspecified */, /* unspecified */>;
    using duration                  = chrono::duration<rep, period>;
    using time_point                = chrono::time_point<gps_clock>;
    static constexpr bool is_steady = /* unspecified */;
 
    static time_point now();
 
    template<class Duration>
      static sys_time<common_type_t<Duration, seconds>>
        to_sys(const gps_time<Duration>& t);
    template<class Duration>
      static gps_time<common_type_t<Duration, seconds>>
        from_sys(const sys_time<Duration>& t);
  };
}

[edit] Class std::chrono::steady_clock

namespace std::chrono {
  class steady_clock {
  public:
    using rep        = /* unspecified */;
    using period     = ratio</* unspecified */, /* unspecified */>;
    using duration   = chrono::duration<rep, period>;
    using time_point = chrono::time_point</* unspecified */, duration>;
    static constexpr bool is_steady = true;
 
    static time_point now() noexcept;
  };
}

[edit] Class std::chrono::high_resolution_clock

namespace std::chrono {
  class high_resolution_clock {
  public:
    using rep        = /* unspecified */;
    using period     = ratio</* unspecified */, /* unspecified */>;
    using duration   = chrono::duration<rep, period>;
    using time_point = chrono::time_point</* unspecified */, duration>;
    static constexpr bool is_steady = /* unspecified */;
 
    static time_point now() noexcept;
  };
}

[edit] Class template std::chrono::clock_time_conversion

namespace std::chrono {
  template<class DestClock, class SourceClock>
  struct clock_time_conversion {};
 
  template<class Clock>
  struct clock_time_conversion<Clock, Clock> {
    template<class Duration>
      time_point<Clock, Duration>
        operator()(const time_point<Clock, Duration>& t) const;
  };
 
  template<>
  struct clock_time_conversion<system_clock, system_clock> {
    template<class Duration>
      sys_time<Duration>
        operator()(const sys_time<Duration>& t) const;
  };
 
  template<>
  struct clock_time_conversion<utc_clock, utc_clock> {
    template<class Duration>
      utc_time<Duration>
        operator()(const utc_time<Duration>& t) const;
  };
 
  template<>
  struct clock_time_conversion<utc_clock, system_clock> {
    template<class Duration>
      utc_time<common_type_t<Duration, seconds>>
        operator()(const sys_time<Duration>& t) const;
  };
 
  template<>
  struct clock_time_conversion<system_clock, utc_clock> {
    template<class Duration>
      sys_time<common_type_t<Duration, seconds>>
        operator()(const utc_time<Duration>& t) const;
  };
 
  template<class SourceClock>
  struct clock_time_conversion<system_clock, SourceClock> {
    template<class Duration>
      auto operator()(const time_point<SourceClock, Duration>& t) const
        -> decltype(SourceClock::to_sys(t));
  };
 
  template<class DestClock>
  struct clock_time_conversion<DestClock, system_clock> {
    template<class Duration>
      auto operator()(const sys_time<Duration>& t) const
        -> decltype(DestClock::from_sys(t));
  };
 
  template<class SourceClock>
  struct clock_time_conversion<utc_clock, SourceClock> {
    template<class Duration>
      auto operator()(const time_point<SourceClock, Duration>& t) const
        -> decltype(SourceClock::to_utc(t));
  };
 
  template<class DestClock>
  struct clock_time_conversion<DestClock, utc_clock> {
    template<class Duration>
      auto operator()(const utc_time<Duration>& t) const
        -> decltype(DestClock::from_utc(t));
  };
}

[edit] Class std::chrono::last_spec

namespace std::chrono {
  struct last_spec {
    explicit last_spec() = default;
  };
}

[edit] Class std::chrono::day

namespace std::chrono {
  class day {
    unsigned char d_;           // exposition only
  public:
    day() = default;
    constexpr explicit day(unsigned d) noexcept;
 
    constexpr day& operator++()    noexcept;
    constexpr day  operator++(int) noexcept;
    constexpr day& operator--()    noexcept;
    constexpr day  operator--(int) noexcept;
 
    constexpr day& operator+=(const days& d) noexcept;
    constexpr day& operator-=(const days& d) noexcept;
 
    constexpr explicit operator unsigned() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::month

namespace std::chrono {
  class month {
    unsigned char m_;           // exposition only
  public:
    month() = default;
    constexpr explicit month(unsigned m) noexcept;
 
    constexpr month& operator++()    noexcept;
    constexpr month  operator++(int) noexcept;
    constexpr month& operator--()    noexcept;
    constexpr month  operator--(int) noexcept;
 
    constexpr month& operator+=(const months& m) noexcept;
    constexpr month& operator-=(const months& m) noexcept;
 
    constexpr explicit operator unsigned() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::year

namespace std::chrono {
  class year {
    short y_;                   // exposition only
  public:
    year() = default;
    constexpr explicit year(int y) noexcept;
 
    constexpr year& operator++()    noexcept;
    constexpr year  operator++(int) noexcept;
    constexpr year& operator--()    noexcept;
    constexpr year  operator--(int) noexcept;
 
    constexpr year& operator+=(const years& y) noexcept;
    constexpr year& operator-=(const years& y) noexcept;
 
    constexpr year operator+() const noexcept;
    constexpr year operator-() const noexcept;
 
    constexpr bool is_leap() const noexcept;
 
    constexpr explicit operator int() const noexcept;
    constexpr bool ok() const noexcept;
 
    static constexpr year min() noexcept;
    static constexpr year max() noexcept;
  };
}

[edit] Class std::chrono::weekday

namespace std::chrono {
  class weekday {
    unsigned char wd_;          // exposition only
  public:
    weekday() = default;
    constexpr explicit weekday(unsigned wd) noexcept;
    constexpr weekday(const sys_days& dp) noexcept;
    constexpr explicit weekday(const local_days& dp) noexcept;
 
    constexpr weekday& operator++()    noexcept;
    constexpr weekday  operator++(int) noexcept;
    constexpr weekday& operator--()    noexcept;
    constexpr weekday  operator--(int) noexcept;
 
    constexpr weekday& operator+=(const days& d) noexcept;
    constexpr weekday& operator-=(const days& d) noexcept;
 
    constexpr unsigned c_encoding() const noexcept;
    constexpr unsigned iso_encoding() const noexcept;
    constexpr bool ok() const noexcept;
 
    constexpr weekday_indexed operator[](unsigned index) const noexcept;
    constexpr weekday_last    operator[](last_spec) const noexcept;
  };
}

[edit] Class std::chrono::weekday_indexed

namespace std::chrono {
  class weekday_indexed {
    chrono::weekday  wd_;       // exposition only
    unsigned char    index_;    // exposition only
 
  public:
    weekday_indexed() = default;
    constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
 
    constexpr chrono::weekday weekday() const noexcept;
    constexpr unsigned        index()   const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::weekday_last

namespace std::chrono {
  class weekday_last {
    chrono::weekday wd_;                // exposition only
 
    public:
    constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
 
    constexpr chrono::weekday weekday() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::month_day

namespace std::chrono {
  class month_day {
    chrono::month m_;           // exposition only
    chrono::day   d_;           // exposition only
 
  public:
    month_day() = default;
    constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
 
    constexpr chrono::month month() const noexcept;
    constexpr chrono::day   day()   const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::month_day_last

namespace std::chrono {
  class month_day_last {
    chrono::month m_;                   // exposition only
 
  public:
    constexpr explicit month_day_last(const chrono::month& m) noexcept;
 
    constexpr chrono::month month() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::month_weekday

namespace std::chrono {
  class month_weekday {
    chrono::month           m_;         // exposition only
    chrono::weekday_indexed wdi_;       // exposition only
  public:
    constexpr month_weekday(const chrono::month& m,
                            const chrono::weekday_indexed& wdi) noexcept;
 
    constexpr chrono::month           month()           const noexcept;
    constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::month_weekday_last

namespace std::chrono {
  class month_weekday_last {
    chrono::month        m_;    // exposition only
    chrono::weekday_last wdl_;  // exposition only
  public:
    constexpr month_weekday_last(const chrono::month& m,
                                 const chrono::weekday_last& wdl) noexcept;
 
    constexpr chrono::month        month()        const noexcept;
    constexpr chrono::weekday_last weekday_last() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::year_month

namespace std::chrono {
  class year_month {
    chrono::year  y_;           // exposition only
    chrono::month m_;           // exposition only
 
  public:
    year_month() = default;
    constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
 
    constexpr chrono::year  year()  const noexcept;
    constexpr chrono::month month() const noexcept;
 
    constexpr year_month& operator+=(const months& dm) noexcept;
    constexpr year_month& operator-=(const months& dm) noexcept;
    constexpr year_month& operator+=(const years& dy)  noexcept;
    constexpr year_month& operator-=(const years& dy)  noexcept;
 
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::year_month_day

namespace std::chrono {
  class year_month_day {
    chrono::year  y_;           // exposition only
    chrono::month m_;           // exposition only
    chrono::day   d_;           // exposition only
 
  public:
    year_month_day() = default;
    constexpr year_month_day(const chrono::year& y, const chrono::month& m,
                             const chrono::day& d) noexcept;
    constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
    constexpr year_month_day(const sys_days& dp) noexcept;
    constexpr explicit year_month_day(const local_days& dp) noexcept;
 
    constexpr year_month_day& operator+=(const months& m) noexcept;
    constexpr year_month_day& operator-=(const months& m) noexcept;
    constexpr year_month_day& operator+=(const years& y)  noexcept;
    constexpr year_month_day& operator-=(const years& y)  noexcept;
 
    constexpr chrono::year  year()  const noexcept;
    constexpr chrono::month month() const noexcept;
    constexpr chrono::day   day()   const noexcept;
 
    constexpr          operator sys_days()   const noexcept;
    constexpr explicit operator local_days() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::year_month_day_last

namespace std::chrono {
  class year_month_day_last {
    chrono::year           y_;          // exposition only
    chrono::month_day_last mdl_;        // exposition only
 
  public:
    constexpr year_month_day_last(const chrono::year& y,
                                  const chrono::month_day_last& mdl) noexcept;
 
    constexpr year_month_day_last& operator+=(const months& m) noexcept;
    constexpr year_month_day_last& operator-=(const months& m) noexcept;
    constexpr year_month_day_last& operator+=(const years& y)  noexcept;
    constexpr year_month_day_last& operator-=(const years& y)  noexcept;
 
    constexpr chrono::year           year()           const noexcept;
    constexpr chrono::month          month()          const noexcept;
    constexpr chrono::month_day_last month_day_last() const noexcept;
    constexpr chrono::day            day()            const noexcept;
 
    constexpr          operator sys_days()   const noexcept;
    constexpr explicit operator local_days() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::year_month_weekday

namespace std::chrono {
  class year_month_weekday {
    chrono::year            y_;         // exposition only
    chrono::month           m_;         // exposition only
    chrono::weekday_indexed wdi_;       // exposition only
 
  public:
    year_month_weekday() = default;
    constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
                                 const chrono::weekday_indexed& wdi) noexcept;
    constexpr year_month_weekday(const sys_days& dp) noexcept;
    constexpr explicit year_month_weekday(const local_days& dp) noexcept;
 
    constexpr year_month_weekday& operator+=(const months& m) noexcept;
    constexpr year_month_weekday& operator-=(const months& m) noexcept;
    constexpr year_month_weekday& operator+=(const years& y)  noexcept;
    constexpr year_month_weekday& operator-=(const years& y)  noexcept;
 
    constexpr chrono::year            year()            const noexcept;
    constexpr chrono::month           month()           const noexcept;
    constexpr chrono::weekday         weekday()         const noexcept;
    constexpr unsigned                index()           const noexcept;
    constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
 
    constexpr          operator sys_days()   const noexcept;
    constexpr explicit operator local_days() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class std::chrono::year_month_weekday_last

namespace std::chrono {
  class year_month_weekday_last {
    chrono::year         y_;    // exposition only
    chrono::month        m_;    // exposition only
    chrono::weekday_last wdl_;  // exposition only
 
  public:
    constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
                                      const chrono::weekday_last& wdl) noexcept;
 
    constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
    constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
    constexpr year_month_weekday_last& operator+=(const years& y)  noexcept;
    constexpr year_month_weekday_last& operator-=(const years& y)  noexcept;
 
    constexpr chrono::year         year()         const noexcept;
    constexpr chrono::month        month()        const noexcept;
    constexpr chrono::weekday      weekday()      const noexcept;
    constexpr chrono::weekday_last weekday_last() const noexcept;
 
    constexpr          operator sys_days()   const noexcept;
    constexpr explicit operator local_days() const noexcept;
    constexpr bool ok() const noexcept;
  };
}

[edit] Class template std::chrono::hh_mm_ss

namespace std::chrono {
  template<class Duration> class hh_mm_ss {
  public:
    static constexpr unsigned fractional_width = /* see description */;
    using precision                            = /* see description */;
 
    constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}
    constexpr explicit hh_mm_ss(Duration d);
 
    constexpr bool is_negative() const noexcept;
    constexpr chrono::hours hours() const noexcept;
    constexpr chrono::minutes minutes() const noexcept;
    constexpr chrono::seconds seconds() const noexcept;
    constexpr precision subseconds() const noexcept;
 
    constexpr explicit operator precision() const noexcept;
    constexpr precision to_duration() const noexcept;
 
  private:
    bool            is_neg;     // exposition only
    chrono::hours   h;          // exposition only
    chrono::minutes m;          // exposition only
    chrono::seconds s;          // exposition only
    precision       ss;         // exposition only
  };
}

[edit] Class std::chrono::tzdb

namespace std::chrono {
  struct tzdb {
    string                 version;
    vector<time_zone>      zones;
    vector<time_zone_link> links;
    vector<leap_second>    leap_seconds;
 
    const time_zone* locate_zone(string_view tz_name) const;
    const time_zone* current_zone() const;
  };
}

[edit] Class std::chrono::tzdb_list

namespace std::chrono {
  class tzdb_list {
  public:
    tzdb_list(const tzdb_list&) = delete;
    tzdb_list& operator=(const tzdb_list&) = delete;
 
    // unspecified additional constructors
 
    class const_iterator;
 
    const tzdb& front() const noexcept;
 
    const_iterator erase_after(const_iterator p);
 
    const_iterator begin() const noexcept;
    const_iterator end()   const noexcept;
 
    const_iterator cbegin() const noexcept;
    const_iterator cend()   const noexcept;
  };
}

[edit] Class std::chrono::nonexistent_local_time

namespace std::chrono {
  class nonexistent_local_time : public runtime_error {
  public:
    template<class Duration>
      nonexistent_local_time(const local_time<Duration>& tp, const local_info& i);
  };
}

[edit] Class std::chrono::ambiguous_local_time

namespace std::chrono {
  class ambiguous_local_time : public runtime_error {
  public:
    template<class Duration>
      ambiguous_local_time(const local_time<Duration>& tp, const local_info& i);
  };
}

[edit] Class std::chrono::sys_info

namespace std::chrono {
  struct sys_info {
    sys_seconds   begin;
    sys_seconds   end;
    seconds       offset;
    minutes       save;
    string        abbrev;
  };
}

[edit] Class std::chrono::local_info

namespace std::chrono {
  struct local_info {
    static constexpr int unique      = 0;
    static constexpr int nonexistent = 1;
    static constexpr int ambiguous   = 2;
 
    int result;
    sys_info first;
    sys_info second;
  };
}

[edit] Class std::chrono::time_zone

namespace std::chrono {
  class time_zone {
  public:
    time_zone(time_zone&&) = default;
    time_zone& operator=(time_zone&&) = default;
 
    // unspecified additional constructors
 
    string_view name() const noexcept;
 
    template<class Duration> sys_info   get_info(const sys_time<Duration>& st)   const;
    template<class Duration> local_info get_info(const local_time<Duration>& tp) const;
 
    template<class Duration>
      sys_time<common_type_t<Duration, seconds>>
        to_sys(const local_time<Duration>& tp) const;
 
    template<class Duration>
      sys_time<common_type_t<Duration, seconds>>
        to_sys(const local_time<Duration>& tp, choose z) const;
 
    template<class Duration>
      local_time<common_type_t<Duration, seconds>>
        to_local(const sys_time<Duration>& tp) const;
  };
}

[edit] Class template std::chrono::zoned_traits

namespace std::chrono {
  template<class T> struct zoned_traits {};
 
  template<> struct zoned_traits<const time_zone*> {
    static const time_zone* default_zone();
    static const time_zone* locate_zone(string_view name);
  };
}

[edit] Class template std::chrono::zoned_time

namespace std::chrono {
  template<class Duration, class TimeZonePtr = const time_zone*>
  class zoned_time {
  public:
    using duration = common_type_t<Duration, seconds>;
 
  private:
    TimeZonePtr        zone_;                   // exposition only
    sys_time<duration> tp_;                     // exposition only
 
    using traits = zoned_traits<TimeZonePtr>;   // exposition only
 
  public:
    zoned_time();
    zoned_time(const zoned_time&) = default;
    zoned_time& operator=(const zoned_time&) = default;
 
    zoned_time(const sys_time<Duration>& st);
    explicit zoned_time(TimeZonePtr z);
    explicit zoned_time(string_view name);
 
    template<class Duration2>
      zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt);
 
    zoned_time(TimeZonePtr z,    const sys_time<Duration>& st);
    zoned_time(string_view name, const sys_time<Duration>& st);
 
    zoned_time(TimeZonePtr z,    const local_time<Duration>& tp);
    zoned_time(string_view name, const local_time<Duration>& tp);
    zoned_time(TimeZonePtr z,    const local_time<Duration>& tp, choose c);
    zoned_time(string_view name, const local_time<Duration>& tp, choose c);
 
    template<class Duration2, class TimeZonePtr2>
      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt);
    template<class Duration2, class TimeZonePtr2>
      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
 
    template<class Duration2, class TimeZonePtr2>
      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt);
    template<class Duration2, class TimeZonePtr2>
      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
 
    zoned_time& operator=(const sys_time<Duration>& st);
    zoned_time& operator=(const local_time<Duration>& ut);
 
    operator sys_time<duration>() const;
    explicit operator local_time<duration>() const;
 
    TimeZonePtr          get_time_zone()  const;
    local_time<duration> get_local_time() const;
    sys_time<duration>   get_sys_time()   const;
    sys_info             get_info()       const;
  };
 
  zoned_time() -> zoned_time<seconds>;
 
  template<class Duration>
    zoned_time(sys_time<Duration>)
      -> zoned_time<common_type_t<Duration, seconds>>;
 
  template<class TimeZonePtrOrName>
    using /*time-zone-representation*/ =        // exposition only
      conditional_t<is_convertible_v<TimeZonePtrOrName, string_view>,
                    const time_zone*,
                    remove_cvref_t<TimeZonePtrOrName>>;
 
  template<class TimeZonePtrOrName>
    zoned_time(TimeZonePtrOrName&&)
      -> zoned_time<seconds, /*time-zone-representation*/<TimeZonePtrOrName>>;
 
  template<class TimeZonePtrOrName, class Duration>
    zoned_time(TimeZonePtrOrName&&, sys_time<Duration>)
      -> zoned_time<common_type_t<Duration, seconds>,
                    /*time-zone-representation*/<TimeZonePtrOrName>>;
 
  template<class TimeZonePtrOrName, class Duration>
    zoned_time(TimeZonePtrOrName&&, local_time<Duration>,
               choose = choose::earliest)
      -> zoned_time<common_type_t<Duration, seconds>,
                    /*time-zone-representation*/<TimeZonePtrOrName>>;
 
  template<class Duration, class TimeZonePtrOrName, class TimeZonePtr2>
    zoned_time(TimeZonePtrOrName&&, zoned_time<Duration, TimeZonePtr2>,
               choose = choose::earliest)
      -> zoned_time<common_type_t<Duration, seconds>,
                    /*time-zone-representation*/<TimeZonePtrOrName>>;
}

[edit] Class std::chrono::leap_second

namespace std::chrono {
  class leap_second {
  public:
    leap_second(const leap_second&)            = default;
    leap_second& operator=(const leap_second&) = default;
 
    // unspecified additional constructors
 
    constexpr sys_seconds date() const noexcept;
    constexpr seconds value() const noexcept;
  };
}

[edit] Class std::chrono::time_zone_link

namespace std::chrono {
  class time_zone_link {
  public:
    time_zone_link(time_zone_link&&)            = default;
    time_zone_link& operator=(time_zone_link&&) = default;
 
    // unspecified additional constructors
 
    string_view name()   const noexcept;
    string_view target() const noexcept;
  };
}

[edit] Class template `local-time-format-t`

namespace std::chrono {
  template<class Duration> struct /*local-time-format-t*/ {       // exposition only
    local_time<Duration> time;                                    // exposition only
    const string* abbrev;                                         // exposition only
    const seconds* offset_sec;                                    // exposition only
  };
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

@@ Line 1: / Line 1: @@
-{{cpp/header/title|chrono}}
+{{cpp/header/title|chrono|notes={{mark c++11}}}}
 {{cpp/header/navbar}}
 This header is part of the [[cpp/chrono|date and time]] library.
-===Classes===
 {{dsc begin}}
-{{dsc namespace | std::chrono}}
+{{dsc h1|Includes}}
-{{dsc inc | cpp/chrono/dsc duration}}
+{{dsc inc|cpp/header/dsc compare}}
-{{dsc inc | cpp/chrono/dsc system_clock}}
-{{dsc inc | cpp/chrono/dsc steady_clock}}
-{{dsc inc | cpp/chrono/dsc high_resolution_clock}}
-{{dsc inc | cpp/chrono/dsc time_point}}
-{{dsc tclass | cpp/chrono/treat_as_floating_point | indicates that a duration is convertible to duration with different tick period }}
-{{dsc tclass | cpp/chrono/duration_values | constructs zero, min, and max values of a tick count of given type}}
-{{dsc h2|Convenience Typedefs}}
+{{dsc h1|Classes}}
-{{dsc namespace | std::chrono}}
-{{dsc | {{lc|std::chrono::nanoseconds}} | duration type with Period {{lc|std::nano}} }}
-{{dsc | {{lc|std::chrono::microseconds}} | duration type with Period {{lc|std::micro}} }}
-{{dsc | {{lc|std::chrono::milliseconds}} | duration type with Period {{lc|std::milli}} }}
-{{dsc | {{lc|std::chrono::seconds}} | duration type with Period {{c|std::ratio<1>}} }}
-{{dsc | {{lc|std::chrono::minutes}} | duration type with Period {{c|std::ratio<60>}} }}
-{{dsc | {{lc|std::chrono::hours}} | duration type with Period {{c|std::ratio<3600>}} }}
-{{dsc | {{lc|std::chrono::days}} | duration type with Period {{c|std::ratio<86400>}} }}
-{{dsc | {{lc|std::chrono::weeks}} | duration type with Period {{c|std::ratio<604800>}} }}
-{{dsc | {{lc|std::chrono::months}} | duration type with Period {{c|std::ratio<2629746>}} }}
-{{dsc | {{lc|std::chrono::years}} | duration type with Period {{c|std::ratio<31556952>}} }}
-{{dsc h2|Specializations}}
-{{dsc namespace | std}}
-{{dsc inc | cpp/chrono/duration/dsc common_type}}
-{{dsc inc | cpp/chrono/time_point/dsc common_type}}
-{{dsc end}}
-===Functions===
-{{dsc begin}}
 {{dsc h2|Duration}}
-{{dsc namespace | std::chrono}}
+{{dsc namespace|std::chrono}}
-{{dsc inc | cpp/chrono/duration/dsc operator_arith4}}
+{{dsc inc|cpp/chrono/dsc duration}}
-{{dsc inc | cpp/chrono/duration/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/dsc treat_as_floating_point}}
-{{dsc inc | cpp/chrono/duration/dsc duration_cast }}
+{{dsc inc|cpp/chrono/dsc duration_values}}
-{{dsc inc | cpp/chrono/duration/dsc floor}}
-{{dsc inc | cpp/chrono/duration/dsc ceil}}
+{{dsc h2|Convenience duration typedefs}}
-{{dsc inc | cpp/chrono/duration/dsc round}}
+{{dsc namespace|std::chrono}}
-{{dsc inc | cpp/chrono/duration/dsc abs}}
+{{dsc|{{lc|std::chrono::nanoseconds}}{{mark c++11}}|duration type with Period {{lc|std::nano}}}}
+{{dsc|{{lc|std::chrono::microseconds}}{{mark c++11}}|duration type with Period {{lc|std::micro}}}}
+{{dsc|{{lc|std::chrono::milliseconds}}{{mark c++11}}|duration type with Period {{lc|std::milli}}}}
+{{dsc|{{lc|std::chrono::seconds}}{{mark c++11}}|duration type with Period {{c/core|std::ratio<1>}}}}
+{{dsc|{{lc|std::chrono::minutes}}{{mark c++11}}|duration type with Period {{c/core|std::ratio<60>}}}}
+{{dsc|{{lc|std::chrono::hours}}{{mark c++11}}|duration type with Period {{c/core|std::ratio<3600>}}}}
+{{dsc|{{lc|std::chrono::days}}{{mark c++20}}|duration type with Period {{c/core|std::ratio<86400>}}}}
+{{dsc|{{lc|std::chrono::weeks}}{{mark c++20}}|duration type with Period {{c/core|std::ratio<604800>}}}}
+{{dsc|{{lc|std::chrono::months}}{{mark c++20}}|duration type with Period {{c/core|std::ratio<2629746>}}}}
+{{dsc|{{lc|std::chrono::years}}{{mark c++20}}|duration type with Period {{c/core|std::ratio<31556952>}}}}
 {{dsc h2|Time point}}
-{{dsc namespace | std::chrono}}
+{{dsc namespace|std::chrono}}
-{{dsc inc | cpp/chrono/time_point/dsc operator_arith2}}
+{{dsc inc|cpp/chrono/dsc time_point}}
-{{dsc inc | cpp/chrono/time_point/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/dsc clock_time_conversion}}
-{{dsc inc | cpp/chrono/time_point/dsc time_point_cast}}
-{{dsc inc | cpp/chrono/time_point/dsc floor}}
-{{dsc inc | cpp/chrono/time_point/dsc ceil}}
-{{dsc inc | cpp/chrono/time_point/dsc round}}
-{{dsc h2|Literals}}
+{{dsc h2|Clocks}}
-{{dsc namespace | std::literals::chrono_literals | inline=true }}
+{{dsc namespace|std::chrono}}
-{{dsc inc | cpp/chrono/dsc operator""h}}
+{{dsc inc|cpp/chrono/dsc is_clock}}
-{{dsc inc | cpp/chrono/dsc operator""min}}
+{{dsc inc|cpp/chrono/dsc system_clock}}
-{{dsc inc | cpp/chrono/dsc operator""s}}
+{{dsc inc|cpp/chrono/dsc steady_clock}}
-{{dsc inc | cpp/chrono/dsc operator""ms}}
+{{dsc inc|cpp/chrono/dsc high_resolution_clock}}
-{{dsc inc | cpp/chrono/dsc operator""us}}
+{{dsc inc|cpp/chrono/dsc utc_clock}}
-{{dsc inc | cpp/chrono/dsc operator""ns}}
+{{dsc inc|cpp/chrono/dsc tai_clock}}
-{{dsc inc | cpp/chrono/dsc operator""d}}
+{{dsc inc|cpp/chrono/dsc gps_clock}}
-{{dsc inc | cpp/chrono/dsc operator""y}}
+{{dsc inc|cpp/chrono/dsc file_clock}}
+{{dsc inc|cpp/chrono/dsc local_t}}
-{{dsc end}}
+{{dsc h2|Calendar}}
+{{dsc namespace|std::chrono}}
+{{dsc inc|cpp/chrono/dsc last_spec}}
+{{dsc inc|cpp/chrono/dsc day}}
+{{dsc inc|cpp/chrono/dsc month}}
+{{dsc inc|cpp/chrono/dsc year}}
+{{dsc inc|cpp/chrono/dsc weekday}}
+{{dsc inc|cpp/chrono/dsc weekday_indexed}}
+{{dsc inc|cpp/chrono/dsc weekday_last}}
+{{dsc inc|cpp/chrono/dsc month_day}}
+{{dsc inc|cpp/chrono/dsc month_day_last}}
+{{dsc inc|cpp/chrono/dsc month_weekday}}
+{{dsc inc|cpp/chrono/dsc month_weekday_last}}
+{{dsc inc|cpp/chrono/dsc year_month}}
+{{dsc inc|cpp/chrono/dsc year_month_day}}
+{{dsc inc|cpp/chrono/dsc year_month_day_last}}
+{{dsc inc|cpp/chrono/dsc year_month_weekday}}
+{{dsc inc|cpp/chrono/dsc year_month_weekday_last}}
-===Synopsis===
+{{dsc h2|Time of day}}
-{{source|1=
+{{dsc namespace|std::chrono}}
-namespace std {
+{{dsc inc|cpp/chrono/dsc hh_mm_ss}}
-  namespace chrono {
-    // class template duration
-    template <class Rep, class Period = ratio<1>> class duration;
-    // class template time_point
-    template <class Clock, class Duration = typename Clock::duration> class time_point;
-  }
-  // common_type specializations
-  template <class Rep1, class Period1, class Rep2, class Period2>
-  struct common_type<chrono::duration<Rep1, Period1>,
-                     chrono::duration<Rep2, Period2>>;
-  template <class Clock, class Duration1, class Duration2>
-  struct common_type<chrono::time_point<Clock, Duration1>,
-                     chrono::time_point<Clock, Duration2>>;
-  namespace chrono {
-    // customization traits
-    template <class Rep> struct treat_as_floating_point;
-    template <class Rep> struct duration_values;
-    template <class Rep>
-    constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;
-    // duration arithmetic
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
-    constexpr operator+(const duration<Rep1, Period1>& lhs,
-                        const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
-    constexpr operator-(const duration<Rep1, Period1>& lhs,
-                        const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period, class Rep2>
-    duration<common_type_t<Rep1, Rep2>, Period>
-    constexpr operator*(const duration<Rep1, Period>& d,
-                        const Rep2& s);
-    template <class Rep1, class Rep2, class Period>
-    duration<common_type_t<Rep1, Rep2>, Period>
-    constexpr operator*(const Rep1& s,
-                        const duration<Rep2, Period>& d);
-    template <class Rep1, class Period, class Rep2>
-    duration<common_type_t<Rep1, Rep2>, Period>
-    constexpr operator/(const duration<Rep1, Period>& d,
-                        const Rep2& s);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    common_type_t<Rep1, Rep2>
-    constexpr operator/(const duration<Rep1, Period1>& lhs,
-                        const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period, class Rep2>
-    duration<common_type_t<Rep1, Rep2>, Period>
-    constexpr operator%(const duration<Rep1, Period>& d,
-                        const Rep2& s);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
-    constexpr operator%(const duration<Rep1, Period1>& lhs,
-                        const duration<Rep2, Period2>& rhs);
-    // duration comparisons
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    constexpr bool operator==(const duration<Rep1, Period1>& lhs,
-                              const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    constexpr bool operator!=(const duration<Rep1, Period1>& lhs,
-                              const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    constexpr bool operator< (const duration<Rep1, Period1>& lhs,
-                              const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
-                              const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    constexpr bool operator> (const duration<Rep1, Period1>& lhs,
-                              const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Rep2, class Period2>
-    constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
-                              const duration<Rep2, Period2>& rhs);
-    // duration_cast
-    template <class ToDuration, class Rep, class Period>
-    constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
-    template <class ToDuration, class Rep, class Period>
-    constexpr ToDuration floor(const duration<Rep, Period>& d);
-    template <class ToDuration, class Rep, class Period>
-    constexpr ToDuration ceil(const duration<Rep, Period>& d);
-    template <class ToDuration, class Rep, class Period>
-    constexpr ToDuration round(const duration<Rep, Period>& d);
-    // convenience typedefs
-    using nanoseconds = duration</*signed integer type of at least 64 bits*/ , nano>;
-    using microseconds = duration</*signed integer type of at least 55 bits*/ , micro>;
-    using milliseconds = duration</*signed integer type of at least 45 bits*/ , milli>;
-    using seconds = duration</*signed integer type of at least 35 bits*/ >;
-    using minutes = duration</*signed integer type of at least 29 bits*/ , ratio< 60>>;
-    using hours = duration</*signed integer type of at least 23 bits*/ , ratio<3600>>;
-    // time_point arithmetic
-    template <class Clock, class Duration1, class Rep2, class Period2>
-    constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
-    operator+(const time_point<Clock, Duration1>& lhs,
-              const duration<Rep2, Period2>& rhs);
-    template <class Rep1, class Period1, class Clock, class Duration2>
-    constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
-    operator+(const duration<Rep1, Period1>& lhs,
-              const time_point<Clock, Duration2>& rhs);
-    template <class Clock, class Duration1, class Rep2, class Period2>
-    constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
-    operator-(const time_point<Clock, Duration1>& lhs,
-              const duration<Rep2, Period2>& rhs);
-    template <class Clock, class Duration1, class Duration2>
-    constexpr common_type_t<Duration1, Duration2>
-    operator-(const time_point<Clock, Duration1>& lhs,
-              const time_point<Clock, Duration2>& rhs);
-    // time_point comparisons
-    template <class Clock, class Duration1, class Duration2>
-    constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
-                              const time_point<Clock, Duration2>& rhs);
-    template <class Clock, class Duration1, class Duration2>
-    constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
-                              const time_point<Clock, Duration2>& rhs);
-    template <class Clock, class Duration1, class Duration2>
-    constexpr bool operator< (const time_point<Clock, Duration1>& lhs,
-                              const time_point<Clock, Duration2>& rhs);
-    template <class Clock, class Duration1, class Duration2>
-    constexpr bool operator<=(const time_point<Clock, Duration1>& lhs,
-                              const time_point<Clock, Duration2>& rhs);
-    template <class Clock, class Duration1, class Duration2>
-    constexpr bool operator> (const time_point<Clock, Duration1>& lhs,
-                              const time_point<Clock, Duration2>& rhs);
-    template <class Clock, class Duration1, class Duration2>
-    constexpr bool operator>=(const time_point<Clock, Duration1>& lhs,
-                              const time_point<Clock, Duration2>& rhs);
-    // time_point_cast
-    template <class ToDuration, class Clock, class Duration>
-    constexpr time_point<Clock, ToDuration>
-    time_point_cast(const time_point<Clock, Duration>& t);
-    template <class ToDuration, class Clock, class Duration>
-    constexpr time_point<Clock, ToDuration>
-    floor(const time_point<Clock, Duration>& tp);
-    template <class ToDuration, class Clock, class Duration>
-    constexpr time_point<Clock, ToDuration>
-    ceil(const time_point<Clock, Duration>& tp);
-    template <class ToDuration, class Clock, class Duration>
-    constexpr time_point<Clock, ToDuration>
-    round(const time_point<Clock, Duration>& tp);
-    // specialized algorithms
-    template <class Rep, class Period>
-    constexpr duration<Rep, Period> abs(duration<Rep, Period> d);
-    // clocks
-    class system_clock;
-    class steady_clock;
-    class high_resolution_clock;
-  }
-  inline namespace literals {
-    inline namespace chrono_literals {
-      // suffixes for duration literals
-      constexpr chrono::hours operator "" h(unsigned long long);
-      constexpr chrono::duration</*unspecified*/,
-                                 ratio<3600,1>> operator "" h(long double);
-      constexpr chrono::minutes operator "" min(unsigned long long);
-      constexpr chrono::duration</*unspecified*/,
-                                 ratio<60,1>> operator "" min(long double);
-      constexpr chrono::seconds operator "" s(unsigned long long);
-      constexpr chrono::duration</*unspecified*/ > operator "" s(long double);
-      constexpr chrono::milliseconds operator "" ms(unsigned long long);
-      constexpr chrono::duration</*unspecified*/,
-                                 milli> operator "" ms(long double);
-      constexpr chrono::microseconds operator "" us(unsigned long long);
-      constexpr chrono::duration</*unspecified*/,
-                                 micro> operator "" us(long double);
-      constexpr chrono::nanoseconds operator "" ns(unsigned long long);
-      constexpr chrono::duration</*unspecified*/,
-                                 nano> operator "" ns(long double);
-      constexpr chrono::day  operator""d(unsigned long long d) noexcept;
-      constexpr chrono::year operator""y(unsigned long long y) noexcept;
-    }
-  }
-  namespace chrono {
-    using namespace literals::chrono_literals;
-  }
-}}
-===={{c|std::chrono::treat_as_floating_point}}====
-{{source|1=
-template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };
-}}
-===={{c|std::chrono::duration_values}}====
+{{dsc h2|Time zone}}
-{{source|1=
+{{dsc namespace|std::chrono}}
-template <class Rep>
+{{dsc inc|cpp/chrono/dsc tzdb}}
-struct duration_values {
+{{dsc inc|cpp/chrono/dsc tzdb_list}}
-public:
+{{dsc inc|cpp/chrono/dsc time_zone}}
-  static constexpr Rep zero();
+{{dsc inc|cpp/chrono/dsc sys_info}}
-  static constexpr Rep min();
+{{dsc inc|cpp/chrono/dsc local_info}}
-  static constexpr Rep max();
+{{dsc inc|cpp/chrono/dsc choose}}
-};
+{{dsc inc|cpp/chrono/dsc zoned_traits}}
-}}
+{{dsc inc|cpp/chrono/dsc zoned_time}}
+{{dsc inc|cpp/chrono/dsc time_zone_link}}
+{{dsc inc|cpp/chrono/dsc nonexistent_local_time}}
+{{dsc inc|cpp/chrono/dsc ambiguous_local_time}}
-===={{c|std::chrono::duration}}====
+{{dsc h2|Leap second}}
-{{source|1=
+{{dsc namespace|std::chrono}}
-template <class Rep, class Period = ratio<1>>
+{{dsc inc|cpp/chrono/dsc leap_second}}
-class duration {
+{{dsc inc|cpp/chrono/utc_clock/dsc leap_second_info}}
-public:
-  using rep = Rep;
-  using period = Period;
-private:
-  rep rep_; // exposition only
-public:
-  // construct/copy/destroy
-  constexpr duration() = default;
-  template <class Rep2>
-  constexpr explicit duration(const Rep2& r);
-  template <class Rep2, class Period2>
-  constexpr duration(const duration<Rep2, Period2>& d);
-  ~duration() = default;
-  duration(const duration&) = default;
-  duration& operator=(const duration&) = default;
-  // observer
-  constexpr rep count() const;
-  // arithmetic
-  constexpr duration operator+() const;
-  constexpr duration operator-() const;
-  constexpr duration& operator++();
-  constexpr duration operator++(int);
-  constexpr duration& operator--();
-  constexpr duration operator--(int);
-  constexpr duration& operator+=(const duration& d);
-  constexpr duration& operator-=(const duration& d);
-  constexpr duration& operator*=(const rep& rhs);
-  constexpr duration& operator/=(const rep& rhs);
-  constexpr duration& operator%=(const rep& rhs);
-  constexpr duration& operator%=(const duration& rhs);
-  // special values
-  static constexpr duration zero();
-  static constexpr duration min();
-  static constexpr duration max();
-};
-}}
-===={{c|std::chrono::time_point}}====
+{{dsc h2|Specializations}}
-{{source|1=
+{{dsc namespace|std}}
-template <class Clock, class Duration = typename Clock::duration>
+{{dsc inc|cpp/chrono/duration/dsc common_type}}
-class time_point {
+{{dsc inc|cpp/chrono/time_point/dsc common_type}}
-public:
+{{dsc inc|cpp/chrono/dsc formatter|duration}}
-  using clock = Clock;
+{{dsc inc|cpp/chrono/dsc formatter|sys_time|system_clock}}
-  using duration = Duration;
+{{dsc inc|cpp/chrono/dsc formatter|utc_time|utc_clock}}
-  using rep = typename duration::rep;
+{{dsc inc|cpp/chrono/dsc formatter|tai_time|tai_clock}}
-  using period = typename duration::period;
+{{dsc inc|cpp/chrono/dsc formatter|gps_time|gps_clock}}
-private:
+{{dsc inc|cpp/chrono/dsc formatter|file_time|file_clock}}
-  duration d_; // exposition only
+{{dsc inc|cpp/chrono/dsc formatter|local_time|local_t}}
-public:
+{{dsc inc|cpp/chrono/dsc formatter|day}}
-  // construct
+{{dsc inc|cpp/chrono/dsc formatter|month}}
-  constexpr time_point(); // has value epoch
+{{dsc inc|cpp/chrono/dsc formatter|year}}
-  constexpr explicit time_point(const duration& d); // same as time_point() + d
+{{dsc inc|cpp/chrono/dsc formatter|weekday}}
-  template <class Duration2>
+{{dsc inc|cpp/chrono/dsc formatter|weekday_indexed}}
-  constexpr time_point(const time_point<clock, Duration2>& t);
+{{dsc inc|cpp/chrono/dsc formatter|weekday_last}}
-  // observer
+{{dsc inc|cpp/chrono/dsc formatter|month_day}}
-  constexpr duration time_since_epoch() const;
+{{dsc inc|cpp/chrono/dsc formatter|month_day_last}}
-  // arithmetic
+{{dsc inc|cpp/chrono/dsc formatter|month_weekday}}
-  constexpr time_point& operator+=(const duration& d);
+{{dsc inc|cpp/chrono/dsc formatter|month_weekday_last}}
-  constexpr time_point& operator-=(const duration& d);
+{{dsc inc|cpp/chrono/dsc formatter|year_month}}
-  // special values
+{{dsc inc|cpp/chrono/dsc formatter|year_month_day}}
-  static constexpr time_point min();
+{{dsc inc|cpp/chrono/dsc formatter|year_month_day_last}}
-  static constexpr time_point max();
+{{dsc inc|cpp/chrono/dsc formatter|year_month_weekday}}
-};
+{{dsc inc|cpp/chrono/dsc formatter|year_month_weekday_last}}
-}}
+{{dsc inc|cpp/chrono/dsc formatter|hh_mm_ss}}
+{{dsc inc|cpp/chrono/dsc formatter|sys_info}}
+{{dsc inc|cpp/chrono/dsc formatter|local_info}}
+{{dsc inc|cpp/chrono/dsc formatter|zoned_time}}
+{{dsc hash|cpp/chrono/duration|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/time_point|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/day|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/month|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/year|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/weekday|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/weekday_indexed|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/weekday_last|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/month_day|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/month_day_last|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/month_weekday|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/month_weekday_last|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/year_month|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/year_month_day|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/year_month_day_last|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/year_month_weekday|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/year_month_weekday_last|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/zoned_time|nested=true|notes={{mark c++26}}}}
+{{dsc hash|cpp/chrono/leap_second|nested=true|notes={{mark c++26}}}}
+{{dsc h2|Forward declarations}}
+{{dsc header|functional}}
+{{dsc inc|cpp/utility/dsc hash}}
+{{dsc break}}
-===={{c|std::chrono::system_clock}}====
+{{dsc h1|Functions}}
-{{source|1=
+{{dsc h2|Duration}}
-class system_clock {
+{{dsc namespace|std::chrono}}
-public:
+{{dsc inc|cpp/chrono/duration/dsc operator_arith4}}
-  using rep = /*see description*/ ;
+{{dsc inc|cpp/chrono/duration/dsc operator_cmp}}
-  using period = ratio</*unspecified*/, /*unspecified*/ >;
+{{dsc inc|cpp/chrono/duration/dsc duration_cast}}
-  using duration = chrono::duration<rep, period>;
+{{dsc inc|cpp/chrono/duration/dsc floor}}
-  using time_point = chrono::time_point<system_clock>;
+{{dsc inc|cpp/chrono/duration/dsc ceil}}
-  static constexpr bool is_steady = /*unspecified*/ ;
+{{dsc inc|cpp/chrono/duration/dsc round}}
-  static time_point now() noexcept;
+{{dsc inc|cpp/chrono/duration/dsc abs}}
-  // Map to C API
-  static time_t to_time_t (const time_point& t) noexcept;
-  static time_point from_time_t(time_t t) noexcept;
-};
-}}
-===={{c|std::chrono::steady_clock}}====
+{{dsc h2|Time point}}
-{{source|1=
+{{dsc namespace|std::chrono}}
-class steady_clock {
+{{dsc inc|cpp/chrono/time_point/dsc operator_arith2}}
-public:
+{{dsc inc|cpp/chrono/time_point/dsc operator_cmp}}
-  using rep = /*unspecified*/ ;
+{{dsc inc|cpp/chrono/time_point/dsc time_point_cast}}
-  using period = ratio</*unspecified*/, /*unspecified*/ >;
+{{dsc inc|cpp/chrono/time_point/dsc floor}}
-  using duration = chrono::duration<rep, period>;
+{{dsc inc|cpp/chrono/time_point/dsc ceil}}
-  using time_point = chrono::time_point</*unspecified*/, duration>;
+{{dsc inc|cpp/chrono/time_point/dsc round}}
-  static constexpr bool is_steady = true;
+{{dsc inc|cpp/chrono/time_point/dsc from_stream|sys_time|system_clock}}
-  static time_point now() noexcept;
+{{dsc inc|cpp/chrono/time_point/dsc from_stream|utc_time|utc_clock}}
-};
+{{dsc inc|cpp/chrono/time_point/dsc from_stream|tai_time|tai_clock}}
-}}
+{{dsc inc|cpp/chrono/time_point/dsc from_stream|gps_time|gps_clock}}
+{{dsc inc|cpp/chrono/time_point/dsc from_stream|file_time|file_clock}}
+{{dsc inc|cpp/chrono/time_point/dsc from_stream|local_time|local_t}}
+{{dsc inc|cpp/chrono/dsc clock_cast}}
-===={{c|std::chrono::high_resolution_clock}}====
+{{dsc h2|Calendar}}
-{{source|1=
+{{dsc namespace|std::chrono}}
-class high_resolution_clock {
+{{dsc inc|cpp/chrono/day/dsc operator_cmp}}
-public:
+{{dsc inc|cpp/chrono/month/dsc operator_cmp}}
-  using rep = /*unspecified*/ ;
+{{dsc inc|cpp/chrono/year/dsc operator_cmp}}
-  using period = ratio</*unspecified*/, /*unspecified*/ >;
+{{dsc inc|cpp/chrono/weekday/dsc operator_cmp}}
-  using duration = chrono::duration<rep, period>;
+{{dsc inc|cpp/chrono/weekday_indexed/dsc operator_cmp}}
-  using time_point = chrono::time_point</*unspecified*/, duration>;
+{{dsc inc|cpp/chrono/weekday_last/dsc operator_cmp}}
-  static constexpr bool is_steady = /*unspecified*/ ;
+{{dsc inc|cpp/chrono/month_day/dsc operator_cmp}}
-  static time_point now() noexcept;
+{{dsc inc|cpp/chrono/month_day_last/dsc operator_cmp}}
-};
+{{dsc inc|cpp/chrono/month_weekday/dsc operator_cmp}}
-}}
+{{dsc inc|cpp/chrono/month_weekday_last/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/year_month/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/year_month_day/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/year_month_day_last/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/year_month_weekday/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/year_month_weekday_last/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/day/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/month/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/year/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/weekday/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/year_month/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/year_month_day/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/year_month_day_last/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/year_month_weekday/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/year_month_weekday_last/dsc operator arith 2}}
+{{dsc inc|cpp/chrono/dsc operator/}}
+{{dsc h2|Time of day}}
+{{dsc namespace|std::chrono}}
+{{dsc inc|cpp/chrono/dsc hour fun}}
+{{dsc h2|Time zone}}
+{{dsc namespace|std::chrono}}
+{{dsc inc|cpp/chrono/dsc tzdb functions}}
+{{dsc inc|cpp/chrono/dsc locate_zone}}
+{{dsc inc|cpp/chrono/time_zone/dsc operator cmp}}
+{{dsc inc|cpp/chrono/zoned_time/dsc operator_cmp}}
+{{dsc inc|cpp/chrono/time_zone_link/dsc operator_cmp}}
+{{dsc h2|Leap second}}
+{{dsc namespace|std::chrono}}
+{{dsc inc|cpp/chrono/utc_clock/dsc get_leap_second_info}}
+{{dsc inc|cpp/chrono/leap_second/dsc operator cmp}}
+{{dsc h2|I/O}}
+{{dsc namespace|std::chrono}}
+{{dsc inc|cpp/chrono/duration/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/time_point/dsc operator ltlt|sys_time|system_clock}}
+{{dsc inc|cpp/chrono/time_point/dsc operator ltlt|utc_time|utc_clock}}
+{{dsc inc|cpp/chrono/time_point/dsc operator ltlt|tai_time|tai_clock}}
+{{dsc inc|cpp/chrono/time_point/dsc operator ltlt|gps_time|gps_clock}}
+{{dsc inc|cpp/chrono/time_point/dsc operator ltlt|file_time|file_clock}}
+{{dsc inc|cpp/chrono/day/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/month/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/year/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/weekday/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/weekday_indexed/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/weekday_last/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/month_day/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/month_day_last/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/month_weekday/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/month_weekday_last/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/year_month/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/year_month_day/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/year_month_day_last/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/year_month_weekday/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/year_month_weekday_last/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/hh_mm_ss/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/sys_info/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/local_info/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/zoned_time/dsc operator ltlt}}
+{{dsc inc|cpp/chrono/day/dsc from_stream}}
+{{dsc inc|cpp/chrono/month/dsc from_stream}}
+{{dsc inc|cpp/chrono/year/dsc from_stream}}
+{{dsc inc|cpp/chrono/weekday/dsc from_stream}}
+{{dsc inc|cpp/chrono/month_day/dsc from_stream}}
+{{dsc inc|cpp/chrono/year_month/dsc from_stream}}
+{{dsc inc|cpp/chrono/year_month_day/dsc from_stream}}
+{{dsc inc|cpp/chrono/dsc parse}}
+{{dsc h2|Literals}}
+{{dsc namespace|std::literals::chrono_literals|inline=true}}
+{{dsc inc|cpp/chrono/dsc operator""h}}
+{{dsc inc|cpp/chrono/dsc operator""min}}
+{{dsc inc|cpp/chrono/dsc operator""s}}
+{{dsc inc|cpp/chrono/dsc operator""ms}}
+{{dsc inc|cpp/chrono/dsc operator""us}}
+{{dsc inc|cpp/chrono/dsc operator""ns}}
+{{dsc inc|cpp/chrono/dsc operator""d}}
+{{dsc inc|cpp/chrono/dsc operator""y}}
+{{dsc end}}
+===Synopsis===
+{{cpp/synopsis/chrono}}
-{{langlinks|ja|zh}}
+{{langlinks|de|es|ja|ru|zh}}

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/header/chrono"

Latest revision as of 07:21, 27 November 2023

Contents

Includes

Classes

Duration

Convenience duration typedefs

Time point

Clocks

Calendar

Time of day

Time zone

Leap second

Specializations

Forward declarations

Functions

Duration

Time point

Calendar

Time of day

Time zone

Leap second

I/O

Literals

[edit] Synopsis

[edit] Class template std::chrono::duration

[edit] Class template std::chrono::time_point

[edit] Class template std::common_type's specialization for std::chrono::duration

[edit] Class template std::common_type's specialization for std::chrono::time_point

[edit] Class template std::chrono::treat_as_floating_point

[edit] Class template std::chrono::duration_values

[edit] Class std::chrono::system_clock

[edit] Class std::chrono::utc_clock

[edit] Class std::chrono::tai_clock

[edit] Class std::chrono::gps_clock

[edit] Class std::chrono::steady_clock

[edit] Class std::chrono::high_resolution_clock

[edit] Class template std::chrono::clock_time_conversion

[edit] Class std::chrono::last_spec

[edit] Class std::chrono::day

[edit] Class std::chrono::month

[edit] Class std::chrono::year

[edit] Class std::chrono::weekday

[edit] Class std::chrono::weekday_indexed

[edit] Class std::chrono::weekday_last

[edit] Class std::chrono::month_day

[edit] Class std::chrono::month_day_last

[edit] Class std::chrono::month_weekday

[edit] Class std::chrono::month_weekday_last

[edit] Class std::chrono::year_month

[edit] Class std::chrono::year_month_day

[edit] Class std::chrono::year_month_day_last

[edit] Class std::chrono::year_month_weekday

[edit] Class std::chrono::year_month_weekday_last

[edit] Class template std::chrono::hh_mm_ss

[edit] Class std::chrono::tzdb

[edit] Class std::chrono::tzdb_list

[edit] Class std::chrono::nonexistent_local_time

[edit] Class std::chrono::ambiguous_local_time

[edit] Class std::chrono::sys_info

[edit] Class std::chrono::local_info

[edit] Class std::chrono::time_zone

[edit] Class template std::chrono::zoned_traits

[edit] Class template std::chrono::zoned_time

[edit] Class std::chrono::leap_second

[edit] Class std::chrono::time_zone_link

[edit] Class template local-time-format-t

Navigation

Toolbox

[edit] Class template `local-time-format-t`