Как преобразовать std :: chrono :: time_point в std :: tm без использования time_t?

Обновленный ответ с улучшенными алгоритмами, ссылка на подробное описание алгоритмов и полное преобразование в std::tm,

Я хотел бы напечатать или извлечь значения год / месяц / день.
Есть ли простой способ конвертировать из time_point в tm (желательно
без повышения)?

Первое, что нужно отметить, это то, что std::chrono::time_point шаблонируется не только на durationно и на часах. Часы подразумевают эпоху. И разные часы могут иметь разные эпохи.

Например, в моей системе std::chrono::high_resolution_clock а также std::chrono::steady_clock иметь эпоху: всякий раз, когда компьютер загружается. Если вы не знаете, в какое время загружался компьютер, вы не сможете его преобразовать. time_point в любую календарную систему.

При этом, вы, вероятно, говорили только о std::chrono::system_clock::time_pointкак это time_pointи только это time_pointтребуется наличие детерминированных отношений с гражданским (григорианским) календарем.

Как оказалось, каждая реализация std::chrono::system_clock Я знаю, использует время unix. Это эпоха Нового Года 1970, пренебрегая високосными секундами.

Это не гарантируется стандартом. Однако вы можете воспользоваться этим фактом, если хотите использовать следующие формулы:

хроносовместимые низкоуровневые алгоритмы даты

Во-первых, предупреждение, я использую последнюю версию C ++ 1y, которая включает в себя отличный новый constexpr инструменты. Если вам нужно отступить от некоторых constexpr атрибуты для вашего компилятора, просто сделайте это.

Учитывая алгоритмы, найденные по ссылке выше, вы можете преобразовать std::chrono::time_point<std::chrono::system_clock, Duration> к std::tm, без использования time_t со следующей функцией:

template <class Duration>
std::tm
make_utc_tm(std::chrono::time_point<std::chrono::system_clock, Duration> tp)
{
using namespace std;
using namespace std::chrono;
typedef duration<int, ratio_multiply<hours::period, ratio<24>>> days;
// t is time duration since 1970-01-01
Duration t = tp.time_since_epoch();
// d is days since 1970-01-01
days d = round_down<days>(t);
// t is now time duration since midnight of day d
t -= d;
// break d down into year/month/day
int year;
unsigned month;
unsigned day;
std::tie(year, month, day) = civil_from_days(d.count());
// start filling in the tm with calendar info
std::tm tm = {0};
tm.tm_year = year - 1900;
tm.tm_mon = month - 1;
tm.tm_mday = day;
tm.tm_wday = weekday_from_days(d.count());
tm.tm_yday = d.count() - days_from_civil(year, 1, 1);
// Fill in the time
tm.tm_hour = duration_cast<hours>(t).count();
t -= hours(tm.tm_hour);
tm.tm_min = duration_cast<minutes>(t).count();
t -= minutes(tm.tm_min);
tm.tm_sec = duration_cast<seconds>(t).count();
return tm;
}

Также обратите внимание, что std::chrono::system_clock::time_point во всех существующих реализациях — это продолжительность в часовом поясе UTC (без учета високосных секунд). Если вы хотите конвертировать time_point используя другой часовой пояс, вам нужно будет добавить / вычесть смещение продолжительности часового пояса в std::chrono::system_clock::time_point до преобразования его с точностью до days, А если вы хотите учесть дополнительные секунды, то отрегулируйте их на соответствующее количество секунд до усечения, чтобы days с помощью этот стол, и знание того, что время Unix соответствует UTC сейчас.

Эту функцию можно проверить с помощью:

#include <iostream>
#include <iomanip>

void
print_tm(const std::tm& tm)
{
using namespace std;
cout << tm.tm_year+1900;
char fill = cout.fill();
cout << setfill('0');
cout << '-' << setw(2) << tm.tm_mon+1;
cout << '-' << setw(2) << tm.tm_mday;
cout << ' ';
switch (tm.tm_wday)
{
case 0:
cout << "Sun";
break;
case 1:
cout << "Mon";
break;
case 2:
cout << "Tue";
break;
case 3:
cout << "Wed";
break;
case 4:
cout << "Thu";
break;
case 5:
cout << "Fri";
break;
case 6:
cout << "Sat";
break;
}
cout << ' ';
cout << ' ' << setw(2) << tm.tm_hour;
cout << ':' << setw(2) << tm.tm_min;
cout << ':' << setw(2) << tm.tm_sec << " UTC.";
cout << setfill(fill);
cout << "  This is " << tm.tm_yday << " days since Jan 1\n";
}

int
main()
{
print_tm(make_utc_tm(std::chrono::system_clock::now()));
}

Который для меня в настоящее время распечатывает:

2013-09-15 вс 18:16:50 UTC. Это 257 дней с 1 января

В случае хроносовместимые низкоуровневые алгоритмы даты переходит в автономный режим или перемещается, вот алгоритмы, используемые в make_utc_tm, Подробные объяснения этих алгоритмов приведены по ссылке выше. Они хорошо проверены и имеют чрезвычайно большой диапазон действия.

// Returns number of days since civil 1970-01-01.  Negative values indicate
//    days prior to 1970-01-01.
// Preconditions:  y-m-d represents a date in the civil (Gregorian) calendar
//                 m is in [1, 12]
//                 d is in [1, last_day_of_month(y, m)]
//                 y is "approximately" in
//                   [numeric_limits<Int>::min()/366, numeric_limits<Int>::max()/366]
//                 Exact range of validity is:
//                 [civil_from_days(numeric_limits<Int>::min()),
//                  civil_from_days(numeric_limits<Int>::max()-719468)]
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;
}

// Returns year/month/day triple in civil calendar
// Preconditions:  z is number of days since 1970-01-01 and is in the range:
//                   [numeric_limits<Int>::min(), numeric_limits<Int>::max()-719468].
template <class Int>
constexpr
std::tuple<Int, unsigned, unsigned>
civil_from_days(Int z) 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");
z += 719468;
const Int era = (z >= 0 ? z : z - 146096) / 146097;
const unsigned doe = static_cast<unsigned>(z - era * 146097);          // [0, 146096]
const unsigned yoe = (doe - doe/1460 + doe/36524 - doe/146096) / 365;  // [0, 399]
const Int y = static_cast<Int>(yoe) + era * 400;
const unsigned doy = doe - (365*yoe + yoe/4 - yoe/100);                // [0, 365]
const unsigned mp = (5*doy + 2)/153;                                   // [0, 11]
const unsigned d = doy - (153*mp+2)/5 + 1;                             // [1, 31]
const unsigned m = mp + (mp < 10 ? 3 : -9);                            // [1, 12]
return std::tuple<Int, unsigned, unsigned>(y + (m <= 2), m, d);
}

template <class Int>
constexpr
unsigned
weekday_from_days(Int z) noexcept
{
return static_cast<unsigned>(z >= -4 ? (z+4) % 7 : (z+5) % 7 + 6);
}

template <class To, class Rep, class Period>
To
round_down(const std::chrono::duration<Rep, Period>& d)
{
To t = std::chrono::duration_cast<To>(d);
if (t > d)
--t;
return t;
}

Обновить

Позже я обернул вышеупомянутые алгоритмы в свободно доступную библиотеку даты / времени задокументировано и доступно здесь. Эта библиотека позволяет легко извлечь год / месяц / день из std::system_clock::time_pointи даже часы: минуты: секунды: доли секунды. И все без прохождения time_t,

Вот простая программа, использующая вышеупомянутую библиотеку только для заголовка, чтобы распечатать текущую дату и время в часовом поясе UTC, с точностью до system_clock::time_point предложения (в данном случае микросекунды):

#include "date.h"#include <iostream>int
main()
{
using namespace date;
using namespace std;
using namespace std::chrono;
auto const now = system_clock::now();
auto const dp = time_point_cast<days>(now);
auto const date = year_month_day(dp);
auto const time = make_time(now-dp);
cout << date << ' ' << time << " UTC\n";
}

Который просто вывод для меня:

2015-05-19 15:03:47.754002 UTC

Эта библиотека эффективно превращается std::chrono::system_clock::time_point в простой в использовании тип даты и времени.