1

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

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

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

1 回答 1

3

这是一个完整的，但不幸的是，在最新版本的 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背面转换为“分解”结构。但是，如果这是您的最终目标，那么修改上面的代码以直接解析为“分解”结构而不是解析为.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" 这里找到。它是一个免费的、开源的、只有头文件的库。在这个链接上，还有完整文档的链接，"date.h"甚至还有视频教程。尽管视频教程是在执行该parse功能之前创建的。

上述程序的输出是：

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

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

如果您需要计算自纪元以来的闰秒，则可以使用同一 GitHub 链接上的另一个库，但不仅仅是标题，需要少量安装。但是使用它是对上面程序的简单修改：

#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 日之间插入的闰秒数。

于 2015-02-28T03:29:06.870 回答