Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/header/chrono"

From cppreference.com
< cpp‎ | header
m (→‎Classes: + mark c++11)
(→‎Synopsis: Update (WIP))
Line 157: Line 157:
 
                                 const duration<Rep2, Period2>& rhs);
 
                                 const duration<Rep2, Period2>& rhs);
 
     template<class Rep1, class Period1, class Rep2, class Period2>
 
     template<class Rep1, class Period1, class Rep2, class Period2>
−
       requires /*see description*/
+
       requires /* see description */
 
       constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
 
       constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
 
                                 const duration<Rep2, Period2>& rhs);
 
                                 const duration<Rep2, Period2>& rhs);
Line 184: Line 184:
  
 
     // convenience typedefs
 
     // convenience typedefs
−
     using nanoseconds  = duration</*signed integer type of at least 64 bits*/, nano>;
+
     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 microseconds = duration</* signed integer type of at least 55 bits */, micro>;
−
     using milliseconds = duration</*signed integer type of at least 45 bits*/, milli>;
+
     using milliseconds = duration</* signed integer type of at least 45 bits */, milli>;
−
     using seconds      = duration</*signed integer type of at least 35 bits*/>;
+
     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 minutes      = duration</* signed integer type of at least 29 bits */,
−
     using hours        = duration</*signed integer type of at least 23 bits*/, ratio<3600>>;
+
                                  ratio<  60>>;
−
     using days        = duration</*signed integer type of at least 25 bits*/,
+
     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>>;
 
                                   ratio_multiply<ratio<24>, hours::period>>;
−
     using weeks        = duration</*signed integer type of at least 22 bits*/,
+
     using weeks        = duration</* signed integer type of at least 22 bits */,
 
                                   ratio_multiply<ratio<7>, days::period>>;
 
                                   ratio_multiply<ratio<7>, days::period>>;
−
     using years        = duration</*signed integer type of at least 17 bits*/,
+
     using years        = duration</* signed integer type of at least 17 bits */,
 
                                   ratio_multiply<ratio<146097, 400>, days::period>>;
 
                                   ratio_multiply<ratio<146097, 400>, days::period>>;
−
     using months      = duration</*signed integer type of at least 20 bits*/,
+
     using months      = duration</* signed integer type of at least 20 bits */,
 
                                   ratio_divide<years::period, ratio<12>>>;
 
                                   ratio_divide<years::period, ratio<12>>>;
  
Line 329: Line 331:
  
 
     // type file_clock
 
     // type file_clock
−
     using file_clock = /*see description*/;
+
     using file_clock = /* see description */;
  
 
     template<class Duration>
 
     template<class Duration>
Line 796: Line 798:
  
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator==(const leap_second& x, const sys_time<Duration>& y);
+
       constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator< (const leap_second& x, const sys_time<Duration>& y);
+
       constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator< (const sys_time<Duration>& x, const leap_second& y);
+
       constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator> (const leap_second& x, const sys_time<Duration>& y);
+
       constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator> (const sys_time<Duration>& x, const leap_second& y);
+
       constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator<=(const leap_second& x, const sys_time<Duration>& y);
+
       constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator<=(const sys_time<Duration>& x, const leap_second& y);
+
       constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator>=(const leap_second& x, const sys_time<Duration>& y);
+
       constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
 
     template<class Duration>
 
     template<class Duration>
−
       bool operator>=(const sys_time<Duration>& x, const leap_second& y);
+
       constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
 
     template<class Duration>
 
     template<class Duration>
 
       requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
 
       requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
Line 872: Line 874:
 
     // parsing
 
     // parsing
 
     template<class charT, class traits, class Alloc, class Parsable>
 
     template<class charT, class traits, class Alloc, class Parsable>
−
       /*unspecified*/
+
       /* unspecified */
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp);
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp);
  
 
     template<class charT, class traits, class Alloc, class Parsable>
 
     template<class charT, class traits, class Alloc, class Parsable>
−
       /*unspecified*/
+
       /* unspecified */
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
 
               basic_string<charT, traits, Alloc>& abbrev);
 
               basic_string<charT, traits, Alloc>& abbrev);
  
 
     template<class charT, class traits, class Alloc, class Parsable>
 
     template<class charT, class traits, class Alloc, class Parsable>
−
       /*unspecified*/
+
       /* unspecified */
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
 
               minutes& offset);
 
               minutes& offset);
  
 
     template<class charT, class traits, class Alloc, class Parsable>
 
     template<class charT, class traits, class Alloc, class Parsable>
−
       /*unspecified*/
+
       /* unspecified */
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
 
         parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
 
               basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
 
               basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
Line 918: Line 920:
 
   inline namespace chrono_literals {
 
   inline namespace chrono_literals {
 
     // suffixes for duration literals
 
     // suffixes for duration literals
−
     constexpr chrono::hours                             operator""h(unsigned long long);
+
     constexpr chrono::hours                   operator""h(unsigned long long);
−
     constexpr chrono::duration</*unspecified*/, ratio<3600, 1>> operator""h(long double);
+
     constexpr chrono::duration</* unspecified */,
 +
                              ratio<3600, 1>> operator""h(long double);
  
−
     constexpr chrono::minutes                         operator""min(unsigned long long);
+
     constexpr chrono::minutes               operator""min(unsigned long long);
−
     constexpr chrono::duration</*unspecified*/, ratio<60, 1>> operator""min(long double);
+
     constexpr chrono::duration</* unspecified */,
 +
                              ratio<60, 1>> operator""min(long double);
  
−
     constexpr chrono::seconds                   operator""s(unsigned long long);
+
     constexpr chrono::seconds                     operator""s(unsigned long long);
−
     constexpr chrono::duration</*unspecified*/> operator""s(long double);
+
     constexpr chrono::duration</* unspecified */> operator""s(long double);
  
−
     constexpr chrono::milliseconds                     operator""ms(unsigned long long);
+
     constexpr chrono::milliseconds                       operator""ms(unsigned long long);
−
     constexpr chrono::duration</*unspecified*/, milli> operator""ms(long double);
+
     constexpr chrono::duration</* unspecified */, milli> operator""ms(long double);
  
−
     constexpr chrono::microseconds                     operator""us(unsigned long long);
+
     constexpr chrono::microseconds                       operator""us(unsigned long long);
−
     constexpr chrono::duration</*unspecified*/, micro> operator""us(long double);
+
     constexpr chrono::duration</* unspecified */, micro> operator""us(long double);
  
−
     constexpr chrono::nanoseconds                     operator""ns(unsigned long long);
+
     constexpr chrono::nanoseconds                       operator""ns(unsigned long long);
−
     constexpr chrono::duration</*unspecified*/, nano> operator""ns(long double);
+
     constexpr chrono::duration</* unspecified */, nano> operator""ns(long double);
  
 
     // non-member functions
 
     // non-member functions
Line 949: Line 953:
 
}
 
}
 
}}
 
}}
−
===={{c|std::chrono::treat_as_floating_point}}====
+
 
 +
====Class template {{lc|std::chrono::duration}}====
 
{{source|1=
 
{{source|1=
−
template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };
+
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;
 +
  };
 +
}
 
}}
 
}}
  
−
===={{c|std::chrono::duration_values}}====
+
====Class template {{lc|std::chrono::time_point}}====
 
{{source|1=
 
{{source|1=
−
template <class Rep>
+
namespace std::chrono {
−
struct duration_values {
+
  template<class Clock, class Duration = typename Clock::duration>
−
public:
+
  class time_point {
−
   static constexpr Rep zero();
+
  public:
−
  static constexpr Rep min();
+
    using clock    = Clock;
−
  static constexpr Rep max();
+
    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;
 +
  };
 +
}
 
}}
 
}}
  
−
===={{c|std::chrono::duration}}====
+
====Class template {{lc|std::common_type}}'s specialization for {{lc|std::chrono::duration}}====
 
{{source|1=
 
{{source|1=
−
template <class Rep, class Period = ratio<1>>
+
namespace std {
−
class duration {
+
  template<class Rep1, class Period1, class Rep2, class Period2>
−
public:
+
    struct common_type<chrono::duration<Rep1, Period1>,
−
  using rep = Rep;
+
                      chrono::duration<Rep2, Period2>> {
−
  using period = Period;
+
      using type = chrono::duration<common_type_t<Rep1, Rep2>, /* see description */>;
−
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}}====
+
====Class template {{lc|std::common_type}}'s specialization for {{lc|std::chrono::time_point}}====
 
{{source|1=
 
{{source|1=
−
template <class Clock, class Duration = typename Clock::duration>
+
namespace std {
−
class time_point {
+
  template<class Clock, class Duration1, class Duration2>
−
public:
+
    struct common_type<chrono::time_point<Clock, Duration1>,
−
  using clock = Clock;
+
                      chrono::time_point<Clock, Duration2>> {
−
  using duration = Duration;
+
      using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;
−
  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+=(const duration& d);
+
−
  constexpr time_point& operator-=(const duration& d);
+
−
  // special values
+
−
  static constexpr time_point min();
+
−
  static constexpr time_point max();
+
−
};
+
 
}}
 
}}
  
−
===={{c|std::chrono::system_clock}}====
+
====Class template {{lc|std::chrono::treat_as_floating_point}}====
 
{{source|1=
 
{{source|1=
−
class system_clock {
+
template<class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };
−
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;
+
−
  // 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}}====
+
====Class template {{lc|std::chrono::duration_values}}====
 
{{source|1=
 
{{source|1=
−
class steady_clock {
+
namespace std::chrono {
−
public:
+
   template<class Rep>
−
   using rep = /*unspecified*/ ;
+
    struct duration_values {
−
  using period = ratio</*unspecified*/, /*unspecified*/ >;
+
    public:
−
  using duration = chrono::duration<rep, period>;
+
      static constexpr Rep zero() noexcept;
−
  using time_point = chrono::time_point</*unspecified*/, duration>;
+
      static constexpr Rep min() noexcept;
−
  static constexpr bool is_steady = true;
+
      static constexpr Rep max() noexcept;
−
  static time_point now() noexcept;
+
    };
−
};
+
}
 
}}
 
}}
  
−
===={{c|std::chrono::high_resolution_clock}}====
+
====Class {{lc|std::chrono::system_clock}}====
 
{{source|1=
 
{{source|1=
−
class high_resolution_clock {
+
namespace std::chrono {
−
public:
+
  class system_clock {
−
   using rep = /*unspecified*/ ;
+
  public:
−
   using period = ratio</*unspecified*/, /*unspecified*/ >;
+
    using rep        = see below;
−
   using duration = chrono::duration<rep, period>;
+
    using period    = ratio</* unspecified */, /* unspecified */>;
−
   using time_point = chrono::time_point</*unspecified*/, duration>;
+
    using duration   = chrono::duration<rep, period>;
−
  static constexpr bool is_steady = /*unspecified*/ ;
+
    using time_point = chrono::time_point<system_clock>;
−
   static time_point now() noexcept;
+
    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;
 +
  };
 +
}
 +
}}
 +
 
 +
====Class {{lc|std::chrono::utc_clock}}====
 +
{{source|1=
 +
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);
 +
   };
 +
}
 +
}}
 +
 
 +
====Class {{lc|std::chrono::tai_clock}}====
 +
{{source|1=
 +
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);
 +
   };
 +
}
 +
}}
 +
 
 +
====Class {{lc|std::chrono::gps_clock}}====
 +
{{source|1=
 +
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);
 +
   };
 +
}
 +
}}
 +
 
 +
====Class {{lc|std::chrono::steady_clock}}====
 +
{{source|1=
 +
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;
 +
  };
 +
}
 +
}}
 +
 
 +
====Class {{lc|std::chrono::high_resolution_clock}}====
 +
{{source|1=
 +
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;
 +
  };
 +
}
 +
}}
 +
 
 +
====Class template {{lc|std::chrono::clock_time_conversion}}====
 +
{{source|1=
 +
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));
 +
  };
 +
}
 
}}
 
}}
  
−
{{langlinks|es|ja|zh}}
+
{{langlinks|de|es|ja|ru|zh}}

Revision as of 07:27, 2 September 2021

 
C++
 
Standard library headers
Algorithms
<algorithm>
<numeric>
Strings
<cctype>
<cstring>
<cuchar> (C++11)
<cwchar>
<cwctype>
<string_view> (C++17)
<string>
Text processing
<clocale>
<codecvt> (C++11/17/26*)
<locale>
<regex> (C++11)
<text_encoding> (C++26)   
Numerics
<cfenv> (C++11)
<cmath>
<complex>
<linalg> (C++26)
<numbers> (C++20)
<random> (C++11)
<valarray>
Time
<chrono> (C++11)
<ctime>
C compatibility
<ccomplex> (C++11/17/20*)
<ciso646> (until C++20)
<cstdalign> (C++11/17/20*)
<cstdbool> (C++11/17/20*)
<ctgmath> (C++11/17/20*)
 

This header is part of the date and time library.

Contents

Classes

Defined in namespace std::chrono
(C++11)
 a time interval
(class template) [edit]
(C++11)
 a point in time
(class template) [edit]
(C++11)
 indicates that a duration is convertible to duration with different tick period
(class template)
(C++20)
 traits class defining how to convert time points of one clock to another
(class template) [edit]
(C++11)
 constructs zero, min, and max values of a tick count of given type
(class template)
(C++20)
 represents a time zone
(class) [edit]
(C++20)
 exception thrown to report that a local time is nonexistent
(class) [edit]
(C++20)
 exception thrown to report that a local time is ambiguous
(class) [edit]
Clocks
Defined in namespace std::chrono
(C++11)
 wall clock time from the system-wide realtime clock
(class) [edit]
(C++11)
 monotonic clock that will never be adjusted
(class) [edit]
(C++11)
 the clock with the shortest tick period available
(class) [edit]
(C++20)
 Clock for Coordinated Universal Time (UTC)
(class) [edit]
(C++20)
 Clock for International Atomic Time (TAI)
(class) [edit]
(C++20)
 Clock for GPS time
(class) [edit]
(C++20)
 Clock used for file time
(typedef) [edit]
(C++20)
 pseudo-clock representing local time
(class) [edit]
Convenience Typedefs
Defined in namespace std::chrono
std::chrono::nanoseconds duration type with Period std::nano
std::chrono::microseconds duration type with Period std::micro
std::chrono::milliseconds duration type with Period std::milli
std::chrono::seconds duration type with Period std::ratio<1>
std::chrono::minutes duration type with Period std::ratio<60>
std::chrono::hours duration type with Period std::ratio<3600>
std::chrono::days duration type with Period std::ratio<86400>
std::chrono::weeks duration type with Period std::ratio<604800>
std::chrono::months duration type with Period std::ratio<2629746>
std::chrono::years duration type with Period std::ratio<31556952>
Specializations
Defined in namespace std
(C++11)
 specializes the std::common_type trait
(class template specialization) [edit]
(C++11)
 specializes the std::common_type trait
(class template specialization) [edit]

Functions

Duration
Defined in namespace std::chrono
(C++11)
 implements arithmetic operations with durations as arguments
(function template) [edit]
(C++11)(C++11)(removed in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)
 compares two durations
(function template) [edit]
(C++11)
 converts a duration to another, with a different tick interval
(function template) [edit]
(C++17)
 converts a duration to another, rounding down
(function template) [edit]
(C++17)
 converts a duration to another, rounding up
(function template) [edit]
(C++17)
 converts a duration to another, rounding to nearest, ties to even
(function template) [edit]
(C++17)
 obtains the absolute value of the duration
(function template) [edit]
Time point
Defined in namespace std::chrono
(C++11)
 performs add and subtract operations involving a time point
(function template) [edit]
(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]
(C++11)
 converts a time point to another time point on the same clock, with a different duration
(function template) [edit]
(C++17)
 converts a time_point to another, rounding down
(function template) [edit]
(C++17)
 converts a time_point to another, rounding up
(function template) [edit]
(C++17)
 converts a time_point to another, rounding to nearest, ties to even
(function template) [edit]
(C++20)
 convert time points of one clock to another
(function template) [edit]
Literals
Defined in inline namespace std::literals::chrono_literals
(C++14)
 a std::chrono::duration literal representing hours
(function) [edit]
(C++14)
 a std::chrono::duration literal representing minutes
(function) [edit]
(C++14)
 a std::chrono::duration literal representing seconds
(function) [edit]
(C++14)
 a std::chrono::duration literal representing milliseconds
(function) [edit]
(C++14)
 a std::chrono::duration literal representing microseconds
(function) [edit]
(C++14)
 a std::chrono::duration literal representing nanoseconds
(function) [edit]
(C++20)
 a std::chrono::day literal representing a day of a month
(function) [edit]
(C++20)
 a std::chrono::year literal representing a particular year
(function) [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 __LocalTimeFormatT;        // exposition only
    template<class Duration>
      __LocalTimeFormatT<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::__LocalTimeFormatT<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 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 basic_string<charT, traits, Alloc>& format, 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,
              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;
  }
}

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;
  };
}

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;
  };
}

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 */>;
    };
}

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>>;
    };
}

Class template std::chrono::treat_as_floating_point

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

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;
    };
}

Class std::chrono::system_clock

namespace std::chrono {
  class system_clock {
  public:
    using rep        = see below;
    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;
  };
}

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);
  };
}

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);
  };
}

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);
  };
}

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;
  };
}

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;
  };
}

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));
  };
}
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/chrono&oldid=133160"