c++ - 如何使用 C++ 解析 DateTime 并将其转换为 RFC 3339

Question

如何解析字符串等效 RFC 3339到任何类型的常规 DateTime 结构？ RFC 3339日期时间格式用于许多规范，例如 Atom Syndication Format .

以下是 ATOM( RFC 3339 ) 格式的日期时间示例:

2005-08-15T15:52:01+04:00

Answer 1

这是一个完整的，但不幸的是，在最新版本的 libc++、libstdc++、VS 实现中，它是一个可移植的程序，它可以将您显示的格式的字符串解析为 std::chrono::system_clock::time_point。 .

我找不到 DateTime你所指的。然而std::chrono::system_clock::time_point 是 “日期时间”结构。 std::chrono::system_clock::time_point是自某个未指定时期以来的某个持续时间(秒、微秒、纳秒等)的计数。并且可以查询std::chrono::system_clock::time_point找出它的持续时间是多少。事实证明，自 1970 年新年以来，每次实现都会测量时间，而忽略闰秒。

#include <chrono>
#include <iostream>
#include <limits>
#include <locale>
#include <sstream>

template <class Int>
// constexpr
Int
days_from_civil(Int y, unsigned m, unsigned d) noexcept
{
    static_assert(std::numeric_limits<unsigned>::digits >= 18,
             "This algorithm has not been ported to a 16 bit unsigned integer");
    static_assert(std::numeric_limits<Int>::digits >= 20,
             "This algorithm has not been ported to a 16 bit signed integer");
    y -= m <= 2;
    const Int era = (y >= 0 ? y : y-399) / 400;
    const unsigned yoe = static_cast<unsigned>(y - era * 400);      // [0, 399]
    const unsigned doy = (153*(m + (m > 2 ? -3 : 9)) + 2)/5 + d-1;  // [0, 365]
    const unsigned doe = yoe * 365 + yoe/4 - yoe/100 + doy;         // [0, 146096]
    return era * 146097 + static_cast<Int>(doe) - 719468;
}

using days = std::chrono::duration
    <int, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>;

namespace std
{

namespace chrono
{

template<class charT, class traits>
std::basic_istream<charT,traits>&
operator >>(std::basic_istream<charT,traits>& is, system_clock::time_point& item)
{
    typename std::basic_istream<charT,traits>::sentry ok(is);
    if (ok)
    {
        std::ios_base::iostate err = std::ios_base::goodbit;
        try
        {
            const std::time_get<charT>& tg = std::use_facet<std::time_get<charT> >
                                                           (is.getloc());
            std::tm t = {};
            const charT pattern[] = "%Y-%m-%dT%H:%M:%S";
            tg.get(is, 0, is, err, &t, begin(pattern), end(pattern)-1);
            if (err == std::ios_base::goodbit)
            {
                charT sign = {};
                is.get(sign);
                err = is.rdstate();
                if (err == std::ios_base::goodbit)
                {
                    if (sign == charT('+') || sign == charT('-'))
                    {
                        std::tm t2 = {};
                        const charT pattern2[] = "%H:%M";
                        tg.get(is, 0, is, err, &t2, begin(pattern2), end(pattern2)-1);
                        if (!(err & std::ios_base::failbit))
                        {
                            auto offset = (sign == charT('+') ? 1 : -1) *
                                          (hours{t2.tm_hour} + minutes{t2.tm_min});
                            item = system_clock::time_point{
                                days{days_from_civil(t.tm_year+1900, t.tm_mon+1,
                                                     t.tm_mday)} +
                                hours{t.tm_hour} + minutes{t.tm_min} + seconds{t.tm_sec} -
                                offset};
                        }
                        else
                        {
                            err |= ios_base::failbit;
                        }
                    }
                    else
                    {
                        err |= ios_base::failbit;
                    }
                }
                else
                {
                    err |= ios_base::failbit;
                }
            }
            else
            {
                err |= ios_base::failbit;
            }
        }
        catch (...)
        {
            err |= std::ios_base::badbit | std::ios_base::failbit;
        }
        is.setstate(err);
    }
    return is;
}

}  // namespace chrono
}  // namespace std

int
main()
{
    std::istringstream infile("2005-08-15T15:52:01+04:00");
    std::chrono::system_clock::time_point tp;
    infile >> tp;
    std::cout << tp.time_since_epoch().count() << '\n';
}

这已经针对 libc++、libstdc++-5.0 和 VS-2015 进行了测试，并分别产生:

1124106721000000
1124106721000000000
11241067210000000

在 libc++ 上，这是自 1970 年新年以来的微秒计数，忽略闰秒。在 libstdc++-5.0 上是纳秒计数，在 VS-2015 上是 100 纳秒计数。

此解决方案的问题在于它涉及将函数插入到 std 命名空间中。将来，C++ 委员会可能会决定将相同的函数插入到相同的命名空间中，这可能会使您的代码无效。

这段代码的另一个问题是它非常复杂。遗憾的是该标准没有提供更简单的解决方案。

这段代码的另一个问题是它没有使用 C 标准中记录的更简单的“%F”、“%T”和“%z”解析模式(尽管被记录为格式化模式)。我通过实验发现它们的使用不是可移植的。

这段代码的另一个问题是它需要 gcc-5.0。如果您正在运行 gcc-4.9，那么您就不走运了。你必须自己解析事情。在 VS-2015 之前，我无法测试 VS 实现。 libc++ 应该没问题(尽管即使 libc++ 不支持“%z”)。

您可以转换 std::chrono::system_clock::time_point如果需要，通过 formulas here 回到“分解”结构.但是，如果这是您的最终目标，那么修改上面的代码以直接解析为“分解”结构而不是 std::chrono::system_clock::time_point 会更有效。 .

免责声明:仅经过非常轻微的测试。我很高兴用任何错误报告更新这个答案。

更新

自从我第一次给出这个答案以来的几年里，我编写了一个库，它使用更简洁的语法完成上述所有计算。

#include "date/date.h"
#include <iostream>
#include <sstream>

int
main()
{
    using namespace date;
    std::istringstream infile{"2005-08-15T15:52:01+04:00"};
    sys_seconds tp;  // This is a system_clock time_point with seconds precision
    infile >> parse("%FT%T%Ez", tp);
    std::cout << tp.time_since_epoch() << " is " << tp << '\n';
}

您可以找到 "date.h" here .它是一个免费的、开源的、只有头文件的库。在 this link也有链接到 full documentation , 对于 "date.h"甚至是 video tutorial .虽然 video tutorial在实现 parse 之前创建功能。

上述程序的输出是:

1124106721s is 2005-08-15 11:52:01

它给出了自纪元以来的秒数(1970-01-01 00:00:00 UTC)和 UTC 的日期/时间(考虑到偏移量)。

如果您需要计算自纪元以来的闰秒， another library在同一个 GitHub 链接可用，但不仅仅是标题，需要少量 installation .但是使用它是对上面程序的简单修改:

#include "date/tz.h"
#include <iostream>
#include <sstream>

int
main()
{
    using namespace date;
    std::istringstream infile{"2005-08-15T15:52:01+04:00"};
    utc_seconds tp;  // This is a utc_clock time_point with seconds precision
    infile >> parse("%FT%T%Ez", tp);
    std::cout << tp.time_since_epoch() << " is " << tp << '\n';
}

现在的输出是:

1124106743s is 2005-08-15 11:52:01

代码的区别在于 "tz.h"现在包括而不是 "date.h" , 和 utc_seconds被解析而不是 sys_seconds . utc_seconds仍然是 std::chrono::time_point ，但现在基于闰秒感知时钟。该程序输出相同的日期/时间，但自纪元以来的秒数现在增加了 22 秒，因为这是在 1970 年 1 月 1 日和 2005 年 8 月 15 日之间插入的闰秒数。