如何使用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 是一个 “DateTime”结构。 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"在于现在包含"tz.h"而不是"date.h" utc_seconds "date.h" ，并且解析了sys_seconds而不是sys_seconds 。 utc_seconds仍然是std::chrono::time_point ，但现在基于闰秒感知时钟。 该程序输出相同的日期/时间，但自纪元以来的秒数现在增加了22秒，因为这是1970-01-01和2005-08-15之间插入的闰秒数。