c++ - 在 C++ 中将时间从一种环境转换为另一种环境

Question

我从服务器端(正在运行 .NET 应用程序)获取 uint64_t 值到用标准 C++ 编写的应用程序(必须在 Windows 和 Linux 上运行)。

此数字代表 Windows 文件时间 - 又名自 1601-01-01 00:00:00 UTC 纪元以来的 100 纳秒间隔。

我需要在我的应用程序中返回时间的字符串表示形式，精度为纳秒(这是我从服务器获得的值的精度)，因此我必须使用 chrono 库。

由于C++的纪元是0001年1月1日到1970年1月1日，我首先需要计算从1970年到1601年的偏移量，并从我从服务器获得的数字中减去它。为了做到这一点，我首先必须将从服务器获得的值表示为 chrono::time_point，并以 100 纳秒的间隔计算纪元 1601-01-01 00:00:00 UTC，以便它和值我得到的是相同的规模。

在我获得 addjustedTimeFromServer - 这是我从服务器获得的值减去(以 chrono::time_point 形式)偏移量之后，我需要将其转换为 std::time_t 以便以精确度提取该值秒，然后从 chrono::time_point 中我需要提取fractional_seconds，这将为我提供纳秒的精度，然后我将它们连接到表示时间的字符串。

这是我的代码。它没有满足我的需要:

using FileTime = duration<int64_t, ratio<1, 10000000>>;
struct std::tm tm;

//create time point for epoch of Windows Filetime (1601-01-01 00:00:00 UTC))
std::istringstream ss("1601-01-01 00:00:00");
ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S"); 
std::time_t tt = mktime(&tm);
std::chrono::system_clock::time_point offset =std::chrono::system_clock::from_time_t(tt); 

//convert the offset into 100-nanosecond intervals scale
auto offset_ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(offset);
auto offset_100ns = FileTime(offset_ns.time_since_epoch());
//substract the offset from i so now it starts from 1970 like the epoch of C++
auto iDuration = FileTime(static_cast<int64_t>(i));
//auto iDuration_ns = std::chrono::time_point_cast<std::chrono::nanoseconds>(iDuration); //doesn't compile - but that's the idea of what i want to do in this line


std::chrono::system_clock::time_point adjustedTime = iDuration/*iDuration_ns*/ - offset /*-offset_100ns*/; //the commented out parts are what i think is the correct thing to do (scale wise) but they don't compile

//convert the time_point into the string representation i need (extract the regular time, up to seconds, with time_t and the nanosecond part with ns.count())
nanoseconds ns = duration_cast<nanoseconds>(adjustedTime.time_since_epoch());
seconds s = duration_cast<seconds>(ns);
std::time_t t = s.count();
std::size_t fractional_seconds = ns.count() % 10000000;
std::cout << std::ctime(&t) << std::endl;
std::cout << fractional_seconds << std::endl;

代码不起作用，我不知道如何修复它。第一个问题(甚至在所有比例转换问题之前)是 mktime(&tm) 给了我一个不正确的值。由于 tm 表示 C++ 纪元之前的值，因此 mktime(&tm) 返回 -1。我需要以某种方式克服它，因为我必须计算 .NET Filetime 纪元的 time_point (1601-01-01 00:00:00 UTC)，以便从我从服务器获得的值中减去它。

我将感谢有关此问题和整个程序的帮助。

P.S 我只是在这段代码中打印，但在最终版本中，我会将两个部分连接到同一个字符串(ctime(&t) 给出的部分和fractional_seconds 给出的部分)

Answer 1

Here is code to do this它实际上是由 MSVC std::lib 团队的一名成员 (Billy O'Neal) 捐赠给该网站的。

此处重复:

// filetime_duration has the same layout as FILETIME; 100ns intervals
using filetime_duration = duration<int64_t, ratio<1, 10'000'000>>;
// January 1, 1601 (NT epoch) - January 1, 1970 (Unix epoch):
constexpr duration<int64_t> nt_to_unix_epoch{INT64_C(-11644473600)};

system_clock::time_point
FILETIME_to_system_clock(FILETIME fileTime)
{
    const filetime_duration asDuration{static_cast<int64_t>(
        (static_cast<uint64_t>(fileTime.dwHighDateTime) << 32)
            | fileTime.dwLowDateTime)};
    const auto withUnixEpoch = asDuration + nt_to_unix_epoch;
    return system_clock::time_point{
        duration_cast<system_clock::duration>(withUnixEpoch)};
}

这会转换为 system_clock::time_point，在 Linux 上具有纳秒精度，在 Windows 上具有 100 纳秒精度。

使用my date/time library ，可以轻松地将 system_clock::time_point 格式化为您想要的任何格式的完全精度。

此外，这里没有使用 Windows FILETIME 结构:

#include "date.h"
#include <string>
#include <iostream>

std::chrono::system_clock::time_point
FILETIME_to_system_clock(std::uint64_t fileTime)
{
    using namespace std;
    using namespace std::chrono;
    // filetime_duration has the same layout as FILETIME; 100ns intervals
    using filetime_duration =duration<int64_t, ratio<1, 10000000>>;
    // January 1, 1601 (NT epoch) - January 1, 1970 (Unix epoch):
    constexpr duration<int64_t> nt_to_unix_epoch{INT64_C(-11644473600)};

    const filetime_duration asDuration{static_cast<int64_t>(fileTime)};
    const auto withUnixEpoch = asDuration + nt_to_unix_epoch;
    return system_clock::time_point{
           duration_cast<system_clock::duration>(withUnixEpoch)};
}

int
main()
{
    std::string s = date::format("%F %T", FILETIME_to_system_clock(131400356659154460));
    std::cout << s << '\n';
}

这只是我的输出:

2017-05-23 17:54:25.915446

请注意，这仅达到微秒精度。在 Linux 上，这将格式化为纳秒精度，因为 system_clock::time_point 在该平台上具有纳秒精度。

如果不是这种情况，您可以像这样强制使用纳秒精度:

    using namespace std::chrono;
    std::string s = date::format("%F %T",
        time_point_cast<nanoseconds>(FILETIME_to_system_clock(131400356659154460)));

我的输出:

2017-05-23 17:54:25.915446000

在此更新中，输出 chrono::time_point 的精度与 Window 的 FILETIME 相同:100-ns 精度:

#include "date.h"
#include <string>
#include <iostream>

using filetime_duration = std::chrono::duration<std::int64_t, std::ratio<1, 10000000>>;
using FileTime = std::chrono::time_point<std::chrono::system_clock, filetime_duration>;
// or more simply:
// using FileTime = date::sys_time<filetime_duration>;

FileTime
FILETIME_to_system_clock(std::uint64_t fileTime)
{
    using namespace std;
    using namespace std::chrono;
    // filetime_duration has the same layout as FILETIME; 100ns intervals
    // January 1, 1601 (NT epoch) - January 1, 1970 (Unix epoch):
    constexpr seconds nt_to_unix_epoch{-11644473600};

    const filetime_duration asDuration{static_cast<int64_t>(fileTime)};
    return FileTime{asDuration + nt_to_unix_epoch};
}

int
main()
{
    using namespace std::chrono;
    std::string s = date::format("%F %T", FILETIME_to_system_clock(131400356659154461));
    std::cout << s << '\n';
}

输出:

2017-05-23 17:54:25.9154461