转换不同的时间单位——std::ratio

C++11之后，STL具有了很多用来测量和显示时间的新类型和函数。STL这部分内容放在std::chrono命名空间中。

本节我们将关注测量时间，以及如何对两种不同的时间单位进行转换，比如：秒到毫秒和微秒的转换。STL已经提供了现成的工具，我们可以自定义时间单位，并且可以无缝的在不同的时间单位间进行转换。

How to do it...

本节，我们写一个小游戏，会让用户输入一个单词，然后记录用户打字的速度，并以不同的时间单位显示所用时间：

包含必要的头文件，并声明所使用的命名空间：

#include <iostream>
#include <chrono>
#include <ratio>
#include <cmath>
#include <iomanip>
#include <optional>

using namespace std;

chrono::duration经常用来表示所用时间的长度，其为秒的倍数或小数，所有STL的程序都由整型类型进行特化。本节中，将使用double进行特化。本节之后，我们更多的会关注已经存在于STL的时间单位：
```
using seconds = chrono::duration<double>;
```
1毫秒为1/1000秒，可以用这个单位来定义秒。ratio_multiply模板参数可以使用STL预定义的milli用来表示seconds::period，其会给我们相应的小数。ratio_multiply为基本时间的倍数：
```
using milliseconds = chrono::duration<
    double, ratio_multiply<seconds::period, milli>>;
```

对于微秒来说也是一样的。可以使用micro表示：

using microseconds = chrono::duration<
    double, ratio_multiply<seconds::period, micro>>;

现在我们实现一个函数，会用来从用户的输入中读取一个字符串，并且统计用户输入所用的时间。这个函数没有参数，在返回用户输入的同时，返回所用的时间，我们用一个组对(pair)将这两个数进行返回：
```
static pair<string, seconds> get_input()
{
    string s;
```
我们需要从用户开始输入时计时，记录一个时间点的方式可以写成如下方式：
```
    const auto tic (chrono::steady_clock::now());
```
现在可以来获取用户的输入了。当我们没有获取成功，将会返回一个默认的元组对象。这个元组对象中的元素都是空：
```
    if (!(cin >> s)) {
        return { {}, {} };
    }
```
成功获取输入后，我们会打上下一个时间戳。然后，返回用户的输入和输入所用的时间。注意这里获取的都是绝对的时间戳，通过计算这两个时间戳的差，我们得到了打印所用的时间：
```
    const auto toc (chrono::steady_clock::now());

    return {s, toc - tic};
}
```

现在让我们来实现主函数，使用一个循环获取用户的输入，直到用户输入正确的字符串为止。在每次循环中，我们都会让用户输入"C++17"，然后调用get_input函数：

int main()
{
    while (true) {
        cout << "Please type the word \"C++17\" as"
                " fast as you can.\n> ";

        const auto [user_input, diff] = get_input();

然后对输入进行检查。当输入为空，程序会终止：
```
       if (user_input == "") { break; }
```

当用户正确的输入"C++17"，我们将会对用户表示祝贺，然后返回其输入所用时间。diff.count()函数会以浮点数的方式返回输入所用的时间。当我们使用STL原始的seconds时间类型时，将会得到一个已舍入的整数，而不是一个小数。通过使用以毫秒和微秒为单位的计时，我们将获得对应单位的计数，然后通过相应的转换方式进行时间单位转换：

        if (user_input == "C++17") {
            cout << "Bravo. You did it in:\n"
                << fixed << setprecision(2)
                << setw(12) << diff.count()
                << " seconds.\n"
                << setw(12) << milliseconds(diff).count()
                << " milliseconds.\n"
                << setw(12) << microseconds(diff).count()
                << " microseconds.\n";
            break;

如果用户输入有误时，我们会提示用户继续输入：

        } else {
            cout << "Sorry, your input does not match."
                       " You may try again.\n";
        }
    }
}

编译并运行程序，就会得到如下的输出。第一次输入时，会有一个错误，程序会让我们重新进行输入。在正确输入之后，我们就会得到输入所花费的时间：

$ ./ratio_conversion
Please type the word "C++17" as fast as you can.
> c+17
Sorry, your input does not match. You may try again.
Please type the word "C++17" as fast as you can.
> C++17
Bravo. You did it in: 
        2.82 seconds.
     2817.95 milliseconds.
  2817948.40 microseconds.

How it works...

本节中对不同时间单位进行转换是，我们需要先选择三个可用的时钟对象的一个。其分别为system_clock，steady_clock和high_resolution_clock，这三个时钟对象都在std::chrono命名空间中。他们有什么区别呢？让我们来看一下：

时钟类型

特性

system_clock

表示系统级别的实时挂钟。想要获取本地时间的话，这是个正确的选择。

steady_clock

表示单调型的时间。这个时间是不可能倒退的，而时间倒退可能会在其他时钟上发生，比如：其最小精度不同，或是在冬令时和夏令时交替时。

high_resolution_clock

STL中可统计最细粒度时钟周期的时钟。

当我们要衡量时间的“距离”，或者计算两个时间点的绝对间隔。即便时钟是112年，5小时，10分钟，1秒(或其他)之后或之前的时间，这都不影响两个时间点间的相对距离。这里我们唯一关注的就是打的两个时间点toc和tic，时钟需要是微秒级别的(许多系统都使用这样的时钟)，因为不同的时钟对于我们的测量有一定的影响。对于这样的需求，steady_clock无疑是最佳的选择。其能根据处理器的时间戳计数器进行实现，只要该时钟开始计数(系统开始运行)就不会停止。

OK，现在来对合适的时间对象进行选择，可以通过chrono::steady_clock::now()对时间点进行保存。now函数会返回一个chrono::time_point<chrono::steady_clock>类的值。两个点之间的差就是所用时间间隔，或chrono::duration类型的时间长度。这个类型是本节的核心类型，其看起来有点复杂。让我们来看一下duration模板类的签名：

template<
    class Rep,
    class Period = std::ratio<1>
> class duration;

我们需要改变的参数类为Rep和Period。Rep很容易解释：其只是一个数值类型用来保存时间点的值。对于已经存在的STL时间单位，都为long long int型。本节中，我们选择了double。因为我们的选择，保存的时间描述也可以转换为毫秒或微秒。当chrono::seconds类型记录的时间为1.2345秒时，其会舍入成一个整数秒数。这样，我们就能使用chrono::microseconds来保存tic和toc之间的时间，并且将其转化为粒度更加大的时间。正因为选择double作为Rep传入，可以对计时的精度在丢失较少精度的情况下，进行向上或向下的调整。

对于我们的计时单位，我们采取了Rep = double方式，所以会在Period上有不同的选择：

using seconds = chrono::duration<double>;
using milliseconds = chrono::duration<double,
    ratio_multiply<seconds::period, milli>>;
using microseconds = chrono::duration<double,
    ratio_multiply<seconds::period, micro>>;

seconds是最简单的时间单位，其为Period = ratio<1>，其他的时间单位就只能进行转换。1毫秒是千分之一秒，所以我们将使用milli特化的seconds::period转化为秒时，就要使用std::ratio<1, 1000>类型(std::ratio<a, b>表示分数值a/b)。ratio_multiply类型是一个编译时函数，其表示对应类型的结果是多个ratio值累加。

可能这看起来非常复杂，那就让我们来看一个例子吧：ratio_multiply<ratio<2, 3>, ratio<4, 5>>的结果为ratio<8, 15>，因为(2/3) * (4/5) = 8/15。

我们结果类型定义等价情况如下：

using seconds = chrono::duration<double, ratio<1, 1>>;
using milliseconds = chrono::duration<double, ratio<1, 1000>>;
using microseconds = chrono::duration<double, ratio<1, 1000000>>;

上面列出的类型，很容易的就能进行转换。当我们具有一个时间间隔d，其类型为seconds，我们就能将其转换成milliseconds。转换只需要通过构造函数就能完成——milliseconds(d)。

There's more...

其他教程和书籍中，你可以会看到使用duration_cast的方式对时间进行转换。当我们具有一个时间间隔类chrono::milliseconds和要转换成的类型chrono::hours时，就需要转换为duration_cast<chrono::hours>(milliseconds_value)，因为这些时间单位都是整型。从一个细粒度的时间单位，转换成一个粗粒度的时间单位，将会带来时间精度的损失，这也是为什么我们使用duration_cast的原因。基于double和float的时间间隔类型不需要进行强制转换。

Previous第8章工具类 Next转换绝对时间和相对时间——std::chrono

Last updated 3 years ago