C++如何将std :: chrono :: time_point转换为long和back

Question

我需要转换std::chrono::time_point为一个long类型(整数64位).我正在开始std::chrono......

这是我的代码:

int main ()
{
     std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();

    auto epoch = now.time_since_epoch();
    auto value = std::chrono::duration_cast<std::chrono::milliseconds>(epoch);
    long duration = value.count();


    std::chrono::duration<long> dur(duration);

    std::chrono::time_point<std::chrono::system_clock> dt(dur);

    if (dt != now)
        std::cout << "Failure." << std::endl;
    else
        std::cout << "Success." << std::endl;
}

此代码编译,但不显示成功.

为什么dt不同于now最后？

该代码缺少什么？

Answer 1

std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();

这是一个很棒的地方auto:

auto now = std::chrono::system_clock::now();

由于您希望以millisecond精确度进行流量,因此最好继续进行以下操作time_point:

auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);

now_ms是一个time_point,基于system_clock,但具有精确度,milliseconds而不是你的精度system_clock.

auto epoch = now_ms.time_since_epoch();

epoch现在有了类型std::chrono::milliseconds.而下一个语句基本上变成了无操作(只是复制并且不进行转换):

auto value = std::chrono::duration_cast<std::chrono::milliseconds>(epoch);

这里:

long duration = value.count();

在你和我的代码中,duration保留了milliseconds自纪元以来的数量system_clock.

这个:

std::chrono::duration<long> dur(duration);

duration用a 创建一个表示long,并且精度为seconds.这实际上reinterpret_cast是milliseconds坚持value到的seconds.这是一个逻辑错误.正确的代码如下所示:

std::chrono::milliseconds dur(duration);

这一行:

std::chrono::time_point<std::chrono::system_clock> dt(dur);

创建一个time_point基于system_clock,具有保持精度system_clock的原始精度(通常小于毫秒)的能力.但是,运行时值将正确反映保持的整数毫秒数(假设我对类型进行了校正dur).

即使有了更正,这个测试也会(几乎总是)失败但是:

if (dt != now)

因为dt保持整数milliseconds,但是now保持整数个刻度比a millisecond(例如microseconds或者nanoseconds)更精细.因此,只有在极少数机会system_clock::now()返回一个完整数量milliseconds的测试通过.

但你可以改为:

if (dt != now_ms)

现在,您将可靠地获得预期结果.

把它们放在一起:

int main ()
{
    auto now = std::chrono::system_clock::now();
    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);

    auto value = now_ms.time_since_epoch();
    long duration = value.count();

    std::chrono::milliseconds dur(duration);

    std::chrono::time_point<std::chrono::system_clock> dt(dur);

    if (dt != now_ms)
        std::cout << "Failure." << std::endl;
    else
        std::cout << "Success." << std::endl;
}

就个人而言,我发现所有std::chrono过于冗长,所以我会将其编码为:

int main ()
{
    using namespace std::chrono;
    auto now = system_clock::now();
    auto now_ms = time_point_cast<milliseconds>(now);

    auto value = now_ms.time_since_epoch();
    long duration = value.count();

    milliseconds dur(duration);

    time_point<system_clock> dt(dur);

    if (dt != now_ms)
        std::cout << "Failure." << std::endl;
    else
        std::cout << "Success." << std::endl;
}

哪个可靠输出:

Success.

最后,我建议消除临时性,以将代码转换time_point和整数类型之间的转换减少到最小.这些转换是危险的,因此您编写的代码越少,操作裸积分类型越好:

int main ()
{
    using namespace std::chrono;
    // Get current time with precision of milliseconds
    auto now = time_point_cast<milliseconds>(system_clock::now());
    // sys_milliseconds is type time_point<system_clock, milliseconds>
    using sys_milliseconds = decltype(now);
    // Convert time_point to signed integral type
    auto integral_duration = now.time_since_epoch().count();
    // Convert signed integral type to time_point
    sys_milliseconds dt{milliseconds{integral_duration}};
    // test
    if (dt != now)
        std::cout << "Failure." << std::endl;
    else
        std::cout << "Success." << std::endl;
}

上述主要危险是不能解释integral_duration为milliseconds上回的方式time_point.减轻这种风险的一种可能方法是写:

    sys_milliseconds dt{sys_milliseconds::duration{integral_duration}};

这样可以降低风险,只需确保sys_milliseconds在出路时使用,并在返回途中的两个地方使用.

和一个例子:比方说,你要转换,并从一个整体它代表什么时间system_clock支持(微秒,10 ^个微秒或纳秒).然后您不必担心如上所述指定毫秒.代码简化为:

int main ()
{
    using namespace std::chrono;
    // Get current time with native precision
    auto now = system_clock::now();
    // Convert time_point to signed integral type
    auto integral_duration = now.time_since_epoch().count();
    // Convert signed integral type to time_point
    system_clock::time_point dt{system_clock::duration{integral_duration}};
    // test
    if (dt != now)
        std::cout << "Failure." << std::endl;
    else
        std::cout << "Success." << std::endl;
}

这是有效的,但是如果你在另一个平台上运行一半转换(转换为积分)而另一半转平(从积分转换为积分),system_clock::duration则会冒两种转换具有不同精度的风险.

Answer 2

作为单行：

long value_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now()).time_since_epoch()).count();

Answer 3

我还要注意有两种方法可以获得时间点的毫秒数。我不确定哪个更好，我已经对它们进行了基准测试，并且它们都具有相同的性能，所以我想这是一个偏好问题。也许霍华德可以插话：

auto now = system_clock::now();

//Cast the time point to ms, then get its duration, then get the duration's count.
auto ms = time_point_cast<milliseconds>(now).time_since_epoch().count();

//Get the time point's duration, then cast to ms, then get its count.
auto ms = duration_cast<milliseconds>(tpBid.time_since_epoch()).count();

第一个在我的脑海中从左到右读得更清楚。