命名空间
变体
操作

标准库头文件 <chrono> (C++11)

来自 cppreference.com
< cpp‎ | header
 
C++
 
标准库头文件
语言支持
概念
<concepts> (C++20)
诊断
<system_error> (C++11)

内存管理
<memory_resource> (C++17)  
元编程
<type_traits> (C++11)
<ratio> (C++11)
通用实用程序
<utility>
<tuple> (C++11)
<optional> (C++17)
<variant> (C++17)
<any> (C++17)
<debugging> (C++26)
<expected> (C++23)
<bitset>
<charconv> (C++17)
<format> (C++20)
<bit> (C++20)

字符串
<cuchar> (C++11)

容器
<flat_set> (C++23)
<span> (C++20)
<mdspan> (C++23)
<inplace_vector> (C++26)
迭代器
<iterator>
范围
<ranges> (C++20)
<generator> (C++23)
算法
数值
<cfenv> (C++11)
<complex>
<cmath>
<linalg> (C++26)
<numbers> (C++20)

时间
<chrono> (C++11)
本地化
<codecvt> (C++11/17/26*)
<text_encoding> (C++26)
输入/输出
<filesystem> (C++17)
<cstdio>
<cinttypes> (C++11)
<strstream> (C++98/26*)
正则表达式
<regex> (C++11)
并发支持
<stop_token> (C++20)
<thread> (C++11)
<atomic> (C++11)
<rcu> (C++26)
<stdatomic.h> (C++23)
<mutex> (C++11)
<shared_mutex> (C++14)

<condition_variable> (C++11)  
<semaphore> (C++20)
<latch> (C++20)

<barrier> (C++20)
<future> (C++11)
<hazard_pointer> (C++26)

C 兼容性
<cstdbool> (C++11/17/20*)  
<ccomplex> (C++11/17/20*)
<ctgmath> (C++11/17/20*)

<cstdalign> (C++11/17/20*)

<ciso646> (直到 C++20)

 

此头文件是 日期和时间 库的一部分。

内容

包含

(C++20)
 三路比较运算符 支持[edit]

类

持续时间
定义在命名空间 std::chrono 中
(C++11)
 时间间隔
(类模板) [edit]
(C++11)
 表示持续时间可以转换为具有不同刻度周期的持续时间
(类模板) [edit]
(C++11)
 构造给定类型的刻度计数的零值、最小值和最大值
(类模板) [edit]
方便的持续时间类型定义
定义在命名空间 std::chrono 中
std::chrono::nanoseconds(C++11) 具有 Period std::nano 的持续时间类型
std::chrono::microseconds(C++11) 具有 Period std::micro 的持续时间类型
std::chrono::milliseconds(C++11) 具有 Period std::milli 的持续时间类型
std::chrono::seconds(C++11) 具有 Period std::ratio<1> 的持续时间类型
std::chrono::minutes(C++11) 具有 Period std::ratio<60> 的持续时间类型
std::chrono::hours(C++11) 具有 Period std::ratio<3600> 的持续时间类型
std::chrono::days(C++20) 具有 Period std::ratio<86400> 的持续时间类型
std::chrono::weeks(C++20) 具有 Period std::ratio<604800> 的持续时间类型
std::chrono::months(C++20) 具有 Period std::ratio<2629746> 的持续时间类型
std::chrono::years(C++20) 具有 Period std::ratio<31556952> 的持续时间类型
时间点
定义在命名空间 std::chrono 中
(C++11)
 时间点
(类模板) [edit]
(C++20)
 特性类，定义如何将一个时钟的时间点转换为另一个时钟的时间点
(类模板) [edit]
时钟
定义在命名空间 std::chrono 中
(C++20)
 确定类型是否为 时钟
(类模板) (变量模板)[edit]
(C++11)
 来自系统范围实时时钟的挂钟时间
(类) [edit]
(C++11)
 单调时钟，永远不会被调整
(类) [edit]
(C++11)
 可用的刻度周期最短的时钟
(类) [edit]
(C++20)
 时钟 用于协调世界时 (UTC)
(类) [edit]
(C++20)
 时钟 用于国际原子时 (TAI)
(类) [edit]
(C++20)
 时钟 用于 GPS 时间
(类) [edit]
(C++20)
 时钟 用于 文件时间
(typedef) [edit]
(C++20)
 表示本地时间的伪时钟
(类) [edit]
日历
定义在命名空间 std::chrono 中
(C++20)
 标记类，表示一个月中的最后一天或星期
(类) [编辑]
(C++20)
 表示一个月中的某一天
(类) [编辑]
(C++20)
 表示一年中的某个月
(类) [编辑]
(C++20)
 表示公历中的某一年
(类) [编辑]
(C++20)
 表示公历中一周中的某一天
(类) [编辑]
(C++20)
 表示一个月中的第n个weekday
(类) [编辑]
(C++20)
 表示一个月中的最后一个weekday
(类) [编辑]
(C++20)
 表示特定day的特定month
(类) [编辑]
(C++20)
 表示特定month的最后一天
(类) [编辑]
(C++20)
 表示特定month的第n个weekday
(类) [编辑]
(C++20)
 表示特定month的最后一个weekday
(类) [编辑]
(C++20)
 表示特定year的特定month
(类) [编辑]
(C++20)
 表示特定year、month和day
(类) [编辑]
(C++20)
 表示特定year和month的最后一天
(类) [编辑]
(C++20)
 表示特定year和month的第n个weekday
(类) [编辑]
(C++20)
 表示特定year和month的最后一个weekday
(类) [编辑]
一天中的时间
定义在命名空间 std::chrono 中
(C++20)
 表示一天中的某一时间
(类模板) [编辑]
时区
定义在命名空间 std::chrono 中
(C++20)
 描述IANA 时区数据库的副本
(类) [编辑]
(C++20)
 表示tzdb的链表
(类) [编辑]
(C++20)
 表示时区
(类) [编辑]
(C++20)
 表示特定时间点时区的相关信息
(类) [编辑]
(C++20)
 表示本地时间到 UNIX 时间转换的相关信息
(类) [编辑]
(C++20)
 选择如何解析模棱两可的本地时间
(枚举) [编辑]
(C++20)
 用于zoned_time的时区指针的特征类
(类模板) [编辑]
(C++20)
 表示时区和时间点
(类) [编辑]
(C++20)
 表示时区的别名
(类) [编辑]
(C++20)
 抛出异常以报告本地时间不存在
(类) [编辑]
(C++20)
 抛出异常以报告本地时间是模棱两可的
(类) [编辑]
闰秒
定义在命名空间 std::chrono 中
(C++20)
 包含有关闰秒插入的信息
(类) [编辑]
(C++20)
 闰秒插入信息
(类) [编辑]
特殊化
在 std 命名空间中定义
(C++11)
 专门化std::common_type 特征
(类模板特殊化) [编辑]
(C++11)
 专门化std::common_type 特征
(类模板特殊化) [编辑]
(C++20)
 duration 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 sys_time 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 utc_time 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 tai_time 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 gps_time 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 file_time 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 local_time 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 day 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 month 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 year 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 weekday 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 weekday_indexed 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 weekday_last 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 month_day 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 month_day_last 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 month_weekday 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 month_weekday_last 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 year_month 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 year_month_day 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 year_month_day_last 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 year_month_weekday 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 year_month_weekday_last 的格式化支持
(类模板特殊化) [编辑]
(C++20)
 hh_mm_ss 格式支持
(类模板特殊化) [编辑]
(C++20)
 sys_info 格式支持
(类模板特殊化) [编辑]
(C++20)
 local_info 格式支持
(类模板特殊化) [编辑]
(C++20)
 zoned_time 格式支持
(类模板特殊化) [编辑]
(C++26)
 对 std::chrono::duration 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::time_point 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::day 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::month 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::year 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::weekday 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::weekday_indexed 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::weekday_last 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::month_day 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::month_day_last 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::month_weekday 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::month_weekday_last 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::year_month 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::year_month_day 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::year_month_day_last 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::year_month_weekday 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::year_month_weekday_last 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::zoned_time 的哈希支持
(类模板特化)
(C++26)
 对 std::chrono::leap_second 的哈希支持
(类模板特化)
前向声明
定义在头文件 <functional> 中
(C++11)
 哈希函数对象
(类模板) [edit]

函数

持续时间
定义在命名空间 std::chrono 中
(C++11)
 使用持续时间作为参数实现算术运算
(函数模板) [edit]
(C++11)(C++11)(C++20 中已删除)(C++11)(C++11)(C++11)(C++11)(C++20)
 比较两个持续时间
(函数模板) [edit]
(C++11)
 将持续时间转换为另一个持续时间，具有不同的刻度间隔
(函数模板) [edit]
(C++17)
 将持续时间转换为另一个持续时间，向下取整
(函数模板) [edit]
(C++17)
 将持续时间转换为另一个持续时间，向上取整
(函数模板) [edit]
(C++17)
 将持续时间转换为另一个持续时间，四舍五入，舍入到偶数
(函数模板) [edit]
(C++17)
 获取持续时间的绝对值
(函数模板) [edit]
时间点
定义在命名空间 std::chrono 中
(C++11)
 执行涉及时间点的加减运算
(函数模板) [edit]
(C++11)(C++11)(C++20 中已删除)(C++11)(C++11)(C++11)(C++11)(C++20)
 比较两个时间点
(函数模板) [edit]
(C++11)
 将一个时钟上的时间点转换为另一个时钟上的时间点，使用不同的持续时间
(函数模板) [edit]
(C++17)
 将时间点转换为另一个时间点，向下取整
(函数模板) [edit]
(C++17)
 将时间点转换为另一个时间点，向上取整
(函数模板) [edit]
(C++17)
 将时间点转换为另一个时间点，四舍五入，舍入到偶数
(函数模板) [edit]
(C++20)
 根据提供的格式从流中解析 sys_time
(函数模板) [edit]
(C++20)
 根据提供的格式从流中解析 utc_time
(函数模板) [edit]
(C++20)
 根据提供的格式从流中解析 tai_time
(函数模板) [edit]
(C++20)
 根据提供的格式从流中解析 gps_time
(函数模板) [edit]
(C++20)
 根据提供的格式从流中解析 file_time
(函数模板) [edit]
(C++20)
 根据提供的格式从流中解析 local_time
(函数模板) [edit]
(C++20)
 将一个时钟上的时间点转换为另一个时钟上的时间点
(函数模板) [edit]
日历
定义在命名空间 std::chrono 中
(C++20)
 比较两个 day 值
(函数) [edit]
(C++20)
 比较两个 month 值
(函数) [edit]
(C++20)
 比较两个 year 值
(函数) [edit]
(C++20)
 比较两个 weekday 值
(函数) [edit]
(C++20)
 比较两个 weekday_indexed 值
(函数) [edit]
(C++20)
 比较两个 weekday_last 值
(函数) [edit]
(C++20)
 比较两个 month_day 值
(函数) [edit]
(C++20)
 比较两个 month_day_last 值
(函数) [edit]
(C++20)
 比较两个 month_weekday 值
(函数) [edit]
(C++20)
 比较两个 month_weekday_last 值
(函数) [edit]
(C++20)
 比较两个 year_month 值
(函数) [edit]
(C++20)
 比较两个 year_month_day 值
(函数) [edit]
(C++20)
 比较两个 year_month_day_last 值
(函数) [edit]
(C++20)
 比较两个 year_month_weekday 值
(函数) [编辑]
(C++20)
 比较两个 year_month_weekday_last 值
(函数) [编辑]
(C++20)
 添加或减去一定数量的天数和 day，或者查找两个 day 之间的差值
(函数) [编辑]
(C++20)
 对 month 进行算术运算
(函数) [编辑]
(C++20)
 对 year 进行算术运算
(函数) [编辑]
(C++20)
 对 weekday 进行算术运算
(函数) [编辑]
(C++20)
 对 year_month 进行算术运算
(函数) [编辑]
(C++20)
 添加或减去 year_month_day 和一定数量的年或月
(函数) [编辑]
(C++20)
 添加或减去 year_month_day_last 和一定数量的年或月
(函数) [编辑]
(C++20)
 添加或减去 year_month_weekday 和一定数量的年或月
(函数) [编辑]
(C++20)
 添加或减去 year_month_weekday_last 和一定数量的年或月
(函数) [编辑]
(C++20)
 格里高利历日期创建的传统语法
(函数) [编辑]
一天中的时间
定义在命名空间 std::chrono 中
(C++20)
 在 12 小时/24 小时格式的当天时间之间进行转换
(函数) [编辑]
时区
定义在命名空间 std::chrono 中
(C++20)
 访问和控制全局时区数据库信息
(函数) [编辑]
(C++20)
 根据名称定位 time_zone
(函数) [编辑]
(C++20)
 比较两个 time_zone 对象
(函数) [编辑]
(C++20)
 比较两个 zoned_time 值
(函数模板) [编辑]
(C++20)
 比较两个 time_zone_link 对象
(函数) [编辑]
闰秒
定义在命名空间 std::chrono 中
(C++20)
 从 utc_time 对象获取闰秒插入信息
(函数模板) [编辑]
(C++20)
 比较两个 leap_second 值或 leap_second 值和 sys_time
(函数模板) [编辑]
I/O
定义在命名空间 std::chrono 中
(C++20)
 对 duration 进行流输出
(函数模板) [编辑]
(C++20)
 对 sys_time 进行流输出
(函数模板) [编辑]
(C++20)
 对 utc_time 进行流输出
(函数模板) [编辑]
(C++20)
 对 tai_time 进行流输出
(函数模板) [编辑]
(C++20)
 对 gps_time 进行流输出
(函数模板) [编辑]
(C++20)
 对 file_time 进行流输出
(函数模板) [编辑]
(C++20)
 将 day 输出到流中
(函数模板) [编辑]
(C++20)
 将 month 输出到流中
(函数模板) [编辑]
(C++20)
 将 year 输出到流中
(函数模板) [编辑]
(C++20)
 将 weekday 输出到流中
(函数模板) [编辑]
(C++20)
 将 weekday_indexed 输出到流中
(函数模板) [编辑]
(C++20)
 将 weekday_last 输出到流中
(函数模板) [编辑]
(C++20)
 将 month_day 输出到流中
(函数模板) [编辑]
(C++20)
 将 month_day_last 输出到流中
(函数模板) [编辑]
(C++20)
 将 month_weekday 输出到流中
(函数模板) [编辑]
(C++20)
 将 month_weekday_last 输出到流中
(函数模板) [编辑]
(C++20)
 将 year_month 输出到流中
(函数模板) [编辑]
(C++20)
 将 year_month_day 输出到流中
(函数模板) [编辑]
(C++20)
 将 year_month_day_last 输出到流中
(函数模板) [编辑]
(C++20)
 将 year_month_weekday 输出到流中
(函数模板) [编辑]
(C++20)
 将 year_month_weekday_last 输出到流中
(函数模板) [编辑]
(C++20)
 将 hh_mm_ss 输出到流中
(函数模板) [编辑]
(C++20)
 将 sys_info 输出到流中
(函数模板) [编辑]
(C++20)
 将 local_info 输出到流中
(函数模板) [编辑]
(C++20)
 将 zoned_time 输出到流中
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析 day
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析 month
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析year。
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析weekday。
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析month_day。
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析year_month。
(函数模板) [编辑]
(C++20)
 根据提供的格式从流中解析year_month_day。
(函数模板) [编辑]
(C++20)
 从流中解析chrono对象。
(函数模板) [编辑]
字面量
定义在内联命名空间std::literals::chrono_literals中。
(C++14)
 一个表示小时的std::chrono::duration字面量。
(函数) [编辑]
(C++14)
 一个表示分钟的std::chrono::duration字面量。
(函数) [编辑]
(C++14)
 一个表示秒的std::chrono::duration字面量。
(函数) [编辑]
(C++14)
 一个表示毫秒的std::chrono::duration字面量。
(函数) [编辑]
(C++14)
 一个表示微秒的std::chrono::duration字面量。
(函数) [编辑]
(C++14)
 一个表示纳秒的std::chrono::duration字面量。
(函数) [编辑]
(C++20)
 一个表示月份中的某一天的std::chrono::day字面量。
(函数) [编辑]
(C++20)
 一个表示特定年份的std::chrono::year字面量。
(函数) [编辑]

[编辑] 概要

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

[编辑] 类模板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;
  };
}

[编辑] 类模板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;
  };
}

[编辑] 类模板std::common_type针对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 */>;
    };
}

[编辑] 类模板std::common_type针对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>>;
    };
}

[编辑] 类模板std::chrono::treat_as_floating_point

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

[编辑] 类模板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;
    };
}

[编辑] 类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;
  };
}

[编辑] 类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);
  };
}

[编辑] 类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);
  };
}

[编辑] 类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);
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类模板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));
  };
}

[编辑] 类std::chrono::last_spec

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

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类模板 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
  };
}

[编辑] 类 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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类 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);
  };
}

[编辑] 类 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);
  };
}

[编辑] 类 std::chrono::sys_info

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

[编辑] 类 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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类模板 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);
  };
}

[编辑] 类模板 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>>;
}

[编辑] 类 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;
  };
}

[编辑] 类 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;
  };
}

[编辑] 类模板 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
  };
}
检索自 "https://cppreference.cn/mwiki/index.php?title=cpp/header/chrono&oldid=163994"