Boost C++ 库

当定义了 BOOST_NO_CXX11_STATIC_ASSERT 时，用户可以选择静态断言的报告方式。定义

默认行为如同定义了 BOOST_CHRONO_USES_ARRAY_ASSERT。

当未定义 BOOST_CHRONO_USES_MPL_ASSERT 时，以下符号定义为

#define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION \
    "A duration representation can not be a duration"
#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO \
    "Second template parameter of duration must be a boost::ratio"
#define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE \
    "duration period must be positive"
#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION \
    "Second template parameter of time_point must be a boost::chrono::duration"

根据所使用的静态断言系统，您将通过符号或文本获得关于失败断言的提示。

当定义了 BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING 时，该库不提供混合错误处理原型

Clock::time_point Clock::now(system::error_code&ec=boost::throws());

这使得它更接近标准，并避免了 Boost.System 依赖，从而使 Boost.Chrono 成为一个仅头文件库。

默认情况下，定义了 BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING。

当定义了 BOOST_CHRONO_HEADER_ONLY 时，该库是仅头文件的。

如果另外定义了 BOOST_USE_WINDOWS_H，则包含 <windows.h>，否则使用 boost/detail/win 中的文件来减少包含 <windows.h> 的影响。

但是，您需要定义 BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING 或链接 Boost.System。

版本 2.0.0 弃用了之前的 I/O 功能。

然而，默认版本始终是版本 1。如果您不想包含已弃用的功能，可以定义 BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0。

BOOST_CHRONO_VERSION 定义了 Boost.Chrono 的版本。默认版本为 1。在这种情况下，除非另有要求，否则会定义以下重大更改或扩展宏

用户可以通过将 BOOST_CHRONO_VERSION 定义为 2 来请求版本 2。在这种情况下，除非另有要求，否则会定义以下重大更改或扩展宏

从 Boost 1.55 开始，BOOST_CHRONO_VERSION 的默认值将更改为 2。

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

duration 模板使用 treat_as_floating_point 特征来确定一个具有一个滴答周期的 duration 是否可以转换为另一个具有不同滴答周期的 duration。如果 treat_as_floating_point<Rep>::value 为 true，则 Rep 是浮点类型，并且 duration 之间允许隐式转换。否则，隐式可转换性取决于 duration 的滴答周期。如果 Rep 是模拟浮点类型的类类型，那么 Rep 的作者可以专门化 treat_as_floating_point，以便 duration 将此 Rep 视为浮点类型。否则，假定 Rep 是整数类型或模拟整数类型的类。

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

duration 模板使用 duration_values 特征来构造 duration 表示（Rep）的特殊值。这是因为表示可能是一个具有某些其他实现来返回这些特殊值的行为的类类型。在这种情况下，该类类型的作者应该专门化 duration_values 以返回指示的值。

static constexpr Rep zero();

static constexpr Rep max();

static constexpr Rep min();

constexpr duration();

效果： 在 C++98 中，构造一个 duration 类型的对象，从 duration_values<rep>::zero() 初始化，否则 duration 未初始化。

template <class Rep2>
constexpr explicit duration(const Rep2& r);

备注： Rep2 可隐式转换为 rep，并且

如果这些约束不满足，此构造函数将不参与重载解析。 注意： 此要求可防止用浮点表示构造基于整数的 duration。此类构造很容易导致对 duration 值的混淆。

示例

duration<int, milli> d(3.5);  // do not compile
duration<int, milli> d(3);    // ok

效果： 构造一个 duration 类型的对象。

后置条件： count() == static_cast<rep>(r)。

template <class Rep2, class Period2>
constexpr duration(const duration<Rep2, Period2>& d);

备注： treat_as_floating_point<rep>::value，或 ratio_divide<Period2, period>::type::den == 1，否则此构造函数将不参与重载解析。 注意：此要求可防止在整数基 duration 之间转换时发生隐式截断误差。此类构造可能导致对 duration 值的混淆。

示例

duration<int, milli> ms(3);
duration<int, micro> us = ms;  // ok
duration<int, milli> ms2 = us; // do not compile

效果： 构造一个 duration 类型的对象，通过 duration_cast<duration>(d).count() 构造 rep_。

constexpr rep count() const;

返回： rep_。

constexpr duration operator+() const;

返回： *this。

constexpr duration operator-() const;

返回： duration(-rep_)。

duration& operator++();

效果： ++rep_。

返回： *this。

duration operator++(int);

返回： duration(rep_++)。

duration& operator--();

效果： --rep_。

返回： *this。

duration operator--(int);

返回： duration(rep_--)。

duration& operator+=(const duration& d);

效果： rep_ += d.count()。

返回： *this。

duration& operator-=(const duration& d);

效果： rep_ -= d.count()。

返回： *this。

duration& operator%=(const duration& d);

效果： rep_ %= d.count()。

返回： *this。

duration& operator*=(const rep& rhs);

效果： rep_ *= rhs。

返回： *this。

duration& operator/=(const rep& rhs);

效果： rep_ /= rhs。

返回： *this。

duration& operator%=(const rep& rhs);

效果： rep_ %= rhs。

返回： *this。

static constexpr duration zero();

返回： duration(duration_values<rep>::zero())。

static constexpr duration min();

返回： duration(duration_values<rep>::min()).

static constexpr duration max();

返回： duration(duration_values<rep>::max())。

template <class Rep1, class Period1, class Rep2, class Period2>
constexpr
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

返回： CD(CD(lhs).count() + CD(rhs).count())，其中 CD 是返回值的类型。

template <class Rep1, class Period1, class Rep2, class Period2>
constexpr
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

返回： CD(CD(lhs).count() - CD(rhs).count())，其中 CD 是返回值的类型。

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator*(const duration<Rep1, Period>& d, const Rep2& s);

要求： 令 CR 表示 Rep1 和 Rep2 的 common_type。此函数不参与重载解析，除非 Rep1 和 Rep2 均可隐式转换为 CR。

返回： CD(CD(d).count() * s)，其中 CD 是返回值的类型。

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator*(const Rep1& s, const duration<Rep2, Period>& d);

要求： 令 CR 表示 Rep1 和 Rep2 的 common_type。此函数不参与重载解析，除非 Rep1 和 Rep2 均可隐式转换为 CR。

返回： d * s。

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator/(const duration<Rep1, Period>& d, const Rep2& s);

要求： 令 CR 表示 Rep1 和 Rep2 的 common_type。此函数不参与重载解析，除非 Rep1 和 Rep2 均可隐式转换为 CR，并且 Rep2 不是 duration 的实例化。

返回： CD(CD(d).count() / s)，其中 CD 是返回值的类型。

template <class Rep1, class Period1, class Rep2, class Period2>
constexpr
typename common_type<Rep1, Rep2>::type
operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

备注： 令 CD 表示两个 duration 参数的 common_type。 返回： 返回 CD(lhs).count() / CD(rhs).count()。

仅当定义了 BOOST_CHRONO_EXTENSIONS 时才包含。

此重载可用于获取由 Rep1 计数的事件的频率。

template <class Rep1, class Rep2, class Period>
constexpr
double operator/(const Rep1& s, const duration<Rep2, Period>& d);

备注： 令 CR 表示 Rep1 和 Rep2 的 common_type。此函数不参与重载解析，除非 Rep1 和 Rep2 均可隐式转换为 CR，并且 Rep1 不是 duration 的实例化。令 CD 表示 duration<CR,Period>。

返回： CR(s)/CD(d).count()，其中 CD 是返回值的类型。

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator%(const duration<Rep1, Period>& d, const Rep2& s);

备注： 令 CR 表示 Rep1 和 Rep2 的 common_type。此函数不参与重载解析，除非 Rep2 可隐式转换为 CR 且 Rep2 不是 duration 的实例化。

返回： CD(CD(d).count() % s) 其中 CD 是返回值的类型。

template <class Rep1, class Period1, class Rep2, class Period2>
constexpr
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
operator%(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs);

备注： 此函数不参与重载解析，除非

返回： CD(CD(lhs).count() % CD(rhs).count()) 其中 CD 是返回值的类型。

template <class Rep1, class Period1, class Rep2, class Period2>
bool operator==(const duration<Rep1, Period1>& lhs,
                const duration<Rep2, Period2>& rhs);

返回： 令 CD 代表两个 duration 参数的 common_type。

返回： 返回 CD(lhs).count() == CD(rhs).count()

template <class Rep1, class Period1, class Rep2, class Period2>
bool operator!=(const duration<Rep1, Period1>& lhs,
                const duration<Rep2, Period2>& rhs);

返回： !(lhs == rhs)。

template <class Rep1, class Period1, class Rep2, class Period2>
bool operator< (const duration<Rep1, Period1>& lhs,
                const duration<Rep2, Period2>& rhs);

返回： 令 CD 代表两个 duration 参数的 common_type。返回 CD(lhs).count() < CD(rhs).count()

template <class Rep1, class Period1, class Rep2, class Period2>
bool operator<=(const duration<Rep1, Period1>& lhs,
                const duration<Rep2, Period2>& rhs);

返回： !(rhs < lhs)。

template <class Rep1, class Period1, class Rep2, class Period2>
bool operator> (const duration<Rep1, Period1>& lhs,
                const duration<Rep2, Period2>& rhs);

返回： rhs < lhs。

template <class Rep1, class Period1, class Rep2, class Period2>
bool operator>=(const duration<Rep1, Period1>& lhs,
                const duration<Rep2, Period2>& rhs);

返回： !(lhs < rhs)。

constexpr time_point();

效果: 构造一个 time_point 对象，用 duration::zero() 初始化 d_。此 time_point 代表纪元。

constexpr time_point(const duration& d);

效果: 构造一个 time_point 对象，用 d 初始化 d_。此 time_point 代表纪元 + d。

template <class Duration2>
constexpr
time_point(const time_point<clock, Duration2>& t);

要求: 除非 Duration2 可以隐式转换为 duration，否则此函数不会参与重载解析。

效果: 构造一个 time_point 对象，用 t.time_since_epoch() 初始化 d_。

constexpr duration time_since_epoch() const;

返回: d_。

constexpr time_point operator+() const;

返回： *this。

constexpr time_point operator-() const;

返回: time_point(-d_)。

time_point& operator++();

效果: ++d_。

返回： *this。

time_point operator++(int);

返回: time_point(d_++)。

time_point& operator--();

效果: --d_。

返回： *this。

time_point operator--(int);

返回: time_point(d_--)。

time_point& operator+=(const rep& r);

效果: d_ += duration(r)。

返回： *this。

time_point& operator-=(const rep& r);

效果: d_ -= duration(r)

返回： *this。

time_point& operator+=(const duration& d);

效果: d_ += d。

返回： *this。

time_point& operator-=(const duration& d);

效果: d_ -= d

返回： *this。

static constexpr time_point min();

返回: time_point(duration::min())。

static constexpr time_point max();

返回: time_point(duration::max())。

template <class Clock, class Duration1, class Rep2, class Period2>
constexpr
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator+(const time_point<Clock, Duration1>& lhs,
          const duration<Rep2, Period2>& rhs);

返回: CT(lhs.time_since_epoch() + rhs)，其中 CT 是返回值的类型。

template <class Rep1, class Period1, class Clock, class Duration2>
constexpr
time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
operator+(const duration<Rep1, Period1>& lhs,
          const time_point<Clock, Duration2>& rhs);

返回: rhs + lhs。

template <class Clock, class Duration1, class Rep2, class Period2>
constexpr
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator-(const time_point<Clock, Duration1>& lhs,
          const duration<Rep2, Period2>& rhs);

返回: lhs + (-rhs)。

template <class Clock, class Duration1, class Duration2>
constexpr
typename common_type<Duration1, Duration2>::type
operator-(const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);

返回: lhs.time_since_epoch() - rhs.time_since_epoch()。

template <class Clock, class Duration1, class Duration2>
constexpr
bool operator==(const time_point<Clock, Duration1>& lhs,
                const time_point<Clock, Duration2>& rhs);

返回: lhs.time_since_epoch() == rhs.time_since_epoch()。

template <class Clock, class Duration1, class Duration2>
constexpr
bool operator!=(const time_point<Clock, Duration1>& lhs,
                const time_point<Clock, Duration2>& rhs);

返回： !(lhs == rhs)。

template <class Clock, class Duration1, class Duration2>
constexpr
bool operator< (const time_point<Clock, Duration1>& lhs,
                const time_point<Clock, Duration2>& rhs);

返回: lhs.time_since_epoch() < rhs.time_since_epoch().

template <class Clock, class Duration1, class Duration2>
constexpr
bool operator<=(const time_point<Clock, Duration1>& lhs,
                const time_point<Clock, Duration2>& rhs);

返回： !(rhs < lhs)。

template <class Clock, class Duration1, class Duration2>
constexpr
bool operator>(const time_point<Clock, Duration1>& lhs,
               const time_point<Clock, Duration2>& rhs);

返回： rhs < lhs。

template <class Clock, class Duration1, class Duration2>
constexpr
bool operator>=(const time_point<Clock, Duration1>& lhs,
                const time_point<Clock, Duration2>& rhs);

返回： !(lhs < rhs)。

time_t to_time_t(const time_point& t) noexcept;

返回: 一个 time_t，使得 time_t 和 t 表示同一时间点，截断到 time_t 和 time_point 之间精度更粗的那个。

time_point from_time_t(time_t t) noexcept;

返回: 一个 time_point，使得 time_point 和 t 表示同一时间点，截断到 time_point 和 time_t 之间精度更粗的那个。