D.1 <chrono>头文件

D.1 <chrono>头文件

<chrono>头文件作为time_point的提供者，具有代表时间点的类，duration类和时钟类。每个时钟都有一个is_steady静态数据成员，这个成员用来表示该时钟是否是一个稳定的时钟(以匀速计时的时钟，且不可调节)。std::steady_clock是唯一个能保证稳定的时钟类。

头文件正文

namespace std
{
  namespace chrono
  {
    template<typename Rep,typename Period = ratio<1>>
    class duration;
    template<
        typename Clock,
        typename Duration = typename Clock::duration>
    class time_point;
    class system_clock;
    class steady_clock;
    typedef unspecified-clock-type high_resolution_clock;
  }
}

D.1.1 std::duration类型模板

std::duration类模板可以用来表示时间。模板参数Rep和Period是用来存储持续时间的数据类型，std::ratio实例代表了时间的长度(几分之一秒)，其表示了在两次“时钟滴答”后的时间(时钟周期)。因此，std::duration<int, std::milli>即为，时间以毫秒数的形式存储到int类型中，而std::duration<short, std::ratio<1,50>>则是记录1/50秒的个数，并将个数存入short类型的变量中，还有std::duration <long long, std::ratio<60,1>>则是将分钟数存储到long long类型的变量中。

类的定义

template <class Rep, class Period=ratio<1> >
class duration
{
public:
  typedef Rep rep;
  typedef Period period;
  constexpr duration() = default;
  ~duration() = default;
  duration(const duration&) = default;
  duration& operator=(const duration&) = default;
  template <class Rep2>
  constexpr explicit duration(const Rep2& r);
  template <class Rep2, class Period2>
  constexpr duration(const duration<Rep2, Period2>& d);
  constexpr rep count() const;
  constexpr duration operator+() const;
  constexpr duration operator-() const;
  duration& operator++();
  duration operator++(int);
  duration& operator--();
  duration operator--(int);
  duration& operator+=(const duration& d);
  duration& operator-=(const duration& d);
  duration& operator*=(const rep& rhs);
  duration& operator/=(const rep& rhs);
  duration& operator%=(const rep& rhs);
  duration& operator%=(const duration& rhs);
  static constexpr duration zero();
  static constexpr duration min();
  static constexpr duration max();
};
template <class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator==(
    const duration<Rep1, Period1>& lhs,
    const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr bool operator!=(
    const duration<Rep1, Period1>& lhs,
    const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr bool operator<(
    const duration<Rep1, Period1>& lhs,
    const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr bool operator<=(
    const duration<Rep1, Period1>& lhs,
    const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr bool operator>(
    const duration<Rep1, Period1>& lhs,
    const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr bool operator>=(
    const duration<Rep1, Period1>& lhs,
    const duration<Rep2, Period2>& rhs);
template <class ToDuration, class Rep, class Period>
    constexpr ToDuration duration_cast(const duration<Rep, Period>& d);

要求

Rep必须是内置数值类型，或是自定义的类数值类型。

Period必须是std::ratio<>实例。

std::Rep 类型

用来记录dration中时钟周期的数量。

声明

typedef Rep rep;

rep类型用来记录duration对象内部的表示。

std::Period 类型

这个类型必须是一个std::ratio的特化实例，用来表示在继续时间中，1s所要记录的次数。例如，当period是std::ratio<1, 50>，duration变量的count()就会在N秒钟返回50N。

声明

typedef Period period;

std::duration 默认构造函数

使用默认值构造std::duration实例

声明

constexpr duration() = default;

效果

duration内部值(例如rep类型的值)都已初始化。

std::duration 需要计数值的转换构造函数

通过给定的数值来构造std::duration实例。

声明

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

效果

duration对象的内部值会使用static_cast<rep>(r)进行初始化。

结果

当Rep2隐式转换为Rep，Rep是浮点类型或Rep2不是浮点类型，这个构造函数才能使用。

后验条件

this->count()==static_cast<rep>(r)

std::duration 需要另一个std::duration值的转化构造函数

通过另一个std::duration类实例中的计数值来构造一个std::duration类实例。

声明

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

结果

duration对象的内部值通过duration_cast<duration<Rep,Period>>(d).count()初始化。

要求

当Rep是一个浮点类或Rep2不是浮点类，且Period2是Period数的倍数(比如，ratio_divide<Period2,Period>::den==1)时，才能调用该重载。当一个较小的数据转换为一个较大的数据时，使用该构造函数就能避免数位截断和精度损失。

后验条件

this->count() == dutation_cast<duration<Rep, Period>>(d).count()

例子

duration<int, ratio<1, 1000>> ms(5);  // 5毫秒
duration<int, ratio<1, 1>> s(ms);  // 错误：不能将ms当做s进行存储
duration<double, ratio<1,1>> s2(ms);  // 合法：s2.count() == 0.005
duration<int, ration<1, 1000000>> us<ms>;  // 合法:us.count() == 5000

std::count 成员函数

查询持续时长。

声明

constexpr rep count() const;

返回

返回duration的内部值，其值类型和rep一样。

std::operator+ 加法操作符

这是一个空操作：只会返回*this的副本。

声明

constexpr duration operator+() const;

返回
*this

std::operator- 减法操作符

返回将内部值只为负数的*this副本。

声明

constexpr duration operator-() const;

返回
duration(--this->count());

std::operator++ 前置自加操作符

增加内部计数值。

声明

duration& operator++();

结果

++this->internal_count;

返回
*this

std::operator++ 后置自加操作符

自加内部计数值，并且返回还没有增加前的*this。

声明

duration operator++(int);

结果

duration temp(*this);
++(*this);
return temp;

std::operator— 前置自减操作符

自减内部计数值

声明

duration& operator--();

结果

--this->internal_count;

返回
*this

std::operator— 前置自减操作符

自减内部计数值，并且返回还没有减少前的*this。

声明

duration operator--(int);

结果

duration temp(*this);
--(*this);
return temp;

std::operator+= 复合赋值操作符

将其他duration对象中的内部值增加到现有duration对象当中。

声明

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

结果

internal_count+=other.count();

返回
*this

std::operator-= 复合赋值操作符

现有duration对象减去其他duration对象中的内部值。

声明

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

结果

internal_count-=other.count();

返回
*this

std::operator*= 复合赋值操作符

内部值乘以一个给定的值。

声明

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

结果

internal_count*=rhs;

返回
*this

std::operator/= 复合赋值操作符

内部值除以一个给定的值。

声明

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

结果

internal_count/=rhs;

返回
*this

std::operator%= 复合赋值操作符

内部值对一个给定的值求余。

声明

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

结果

internal_count%=rhs;

返回
*this

std::operator%= 复合赋值操作符(重载)

内部值对另一个duration类的内部值求余。

声明

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

结果

internal_count%=rhs.count();

返回
*this

std::zero 静态成员函数

返回一个内部值为0的duration对象。

声明

constexpr duration zero();

duration(duration_values<rep>::zero());

std::min 静态成员函数

返回duration类实例化后能表示的最小值。

声明

constexpr duration min();

duration(duration_values<rep>::min());

std::max 静态成员函数

返回duration类实例化后能表示的最大值。

声明

constexpr duration max();

duration(duration_values<rep>::max());