Convert UTC time_t to UTC tm

Question

All my internal times are UTC stored in time_t. I need to convert them to struct tm. If I use localtime the time is correct, except that tm_isdst may be set resulting in the time being off an hour. If I use gmtime it gets the wrong time, off by the time zone difference.

Edit I am looking for a cross platform solution that works in Windows and Linux

Answer 1

Here is a cross platform solution that requires C++11 or better, and a free, open-source, header-only date library. And when your vendor brings you C++20, you can loose the date library as it is incorporated into C++20 <chrono>.

It is actually easier to convert from time_t to a UTC tm by going through <chrono> than it is to use the C API. There do exist various extensions to do this on each platform, but the extensions have different syntaxes. This solution has a uniform syntax across all platforms.

In C++11, though not specified, it is a de-facto standard that both time_t and std::chrono::system_clock track Unix Time, though at different precisions. In C++20 this becomes specified for std::chrono::system_clock. For time_t the de-facto precision is seconds. One can take advantage of this knowledge to create extremely efficient conversions between the C API and the C++ <chrono> API.

Step 1: Convert time_t to a chrono::time_point

This is very easy and efficient:

date::sys_seconds
to_chrono(std::time_t t)
{
    using namespace date;
    using namespace std::chrono;

    return sys_seconds{seconds{t}};
}

date::sys_seconds is simply a type alias for:

std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>

I.e. a time_point based on system_clock but with seconds precision.

All this function does is change type from time_t to seconds and then to time_point. No actual computation is done. Here is an optimized clang compilation of to_chrono:

    .globl  __Z9to_chronol          ## -- Begin function _Z9to_chronol
    .p2align    4, 0x90
__Z9to_chronol:                         ## @_Z9to_chronol
    .cfi_startproc
## %bb.0:
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    movq    %rdi, %rax
    popq    %rbp
    retq
    .cfi_endproc

All that's there is the boiler plate for a function call. And if you inline this, even that disappears.

Furthermore this function will port to C++20 by simply removing using namespace date and changing date::sys_seconds to std::chrono::sys_seconds.

Step 2: Convert sys_seconds to a tm

This is where the computation happens:

std::tm
to_tm(date::sys_seconds tp)
{
    using namespace date;
    using namespace std::chrono;

    auto td = floor<days>(tp);
    year_month_day ymd = td;
    hh_mm_ss<seconds> tod{tp - td};  // <seconds> can be omitted in C++17
    tm t{};
    t.tm_sec  = tod.seconds().count();
    t.tm_min  = tod.minutes().count();
    t.tm_hour = tod.hours().count();
    t.tm_mday = unsigned{ymd.day()};
    t.tm_mon  = (ymd.month() - January).count();
    t.tm_year = (ymd.year() - 1900_y).count();
    t.tm_wday = weekday{td}.c_encoding();
    t.tm_yday = (td - sys_days{ymd.year()/January/1}).count();
    t.tm_isdst = 0;
    return t;
}

All of the computation happens in the first three lines:

auto td = floor<days>(tp);
year_month_day ymd = td;
hh_mm_ss<seconds> tod{tp - td};  // <seconds> can be omitted in C++17

Then the rest of the function just extracts the fields to fill out the tm members.

auto td = floor<days>(tp);

The first line above simply truncates the precision of the time_point from seconds to days, rounding down towards negative infinity (even for time_points prior to the 1970-01-01 epoch). This is little more than a divide by 86400.

year_month_day ymd = td;

The second line above takes the count of days since the epoch and converts it to a {year, month, day} data structure. This is where most of the computation happens.

hh_mm_ss<seconds> tod{tp - td};  // <seconds> can be omitted in C++17

The third line above subtracts the days-precision time_point from the seconds-precision time_point resulting in a std::chrono::seconds time duration since midnight UTC. This duration is then broken out into a {hours, minutes, seconds} data structure (the type hh_mm_ss). In C++17 this line can optionally be simplified to:

hh_mm_ss tod{tp - td};  // <seconds> can be omitted in C++17

Now to_tm simply extracts the fields to fill out the tm according to the C API.

int   tm_sec;        //   seconds after the minute -- [0, 60]
int   tm_min;        //   minutes after the hour -- [0, 59]
int   tm_hour;       //   hours since midnight -- [0, 23]
int   tm_mday;       //   day of the month -- [1, 31]
int   tm_mon;        //   months since January -- [0, 11]
int   tm_year;       //   years since 1900

int tm_wday; // days since Sunday -- [0, 6]
int tm_yday; // days since January 1 -- [0, 365]
int tm_isdst; // Daylight Saving Time flag

It is important to first zero-initialize the tm because different platforms have extra tm data members as extensions that are best given the value 0.

tm t{};

For the hours, minutes and seconds one simply extracts the appropriate chrono::duration from tod and then extracts the integral values with the .count() member function:

t.tm_sec  = tod.seconds().count();
t.tm_min  = tod.minutes().count();
t.tm_hour = tod.hours().count();

day has an explicit conversion to unsigned and this is one of the few places where the C API doesn't give a tm data member an unexpected bias:

t.tm_mday = unsigned{ymd.day()};

tm_mon is defined as "months since January" so that bias has to be taken into account. One can subtract January from the month, resulting in a months duration. This is a chrono::duration, and the integral value can be extracted with the .count() member function:

t.tm_mon  = (ymd.month() - January).count();

Similarly, tm_year is years since 1900:

t.tm_year = (ymd.year() - 1900_y).count();

One can convert a days-precision time_point (td) to a weekday with conversion syntax, and then weekday has a member function .c_encoding() to extract an integral value which matches the C API: days since Sunday -- [0, 6]. Alternatively there is also a .iso_encoding() member function if one desires the ISO encoding [Mon, Sun] -> [1, 7].

t.tm_wday = weekday{td}.c_encoding();

tm_yday is days since January 1 -- [0, 365]. This is easily computed by subtracting the first of the year from the days-precision time_point (td), creating a days chrono::duration:

t.tm_yday = (td - sys_days{ymd.year()/January/1}).count();

Finally tm_isdst should be set to 0 to indicate Daylight Saving Time is not in effect. Technically this step was already done when zero-initializing tm, but is repeated here for readability purposes:

t.tm_isdst = 0;

to_tm can be ported to C++20 by:

• remove using namespace date;
• change date::sys_seconds to std::chrono::sys_seconds
• change 1900_y to 1900y

Example Use:

Given a time_t, here is how you can use these functions to convert it to a UTC tm:

std::time_t t = std::time(nullptr);
std::tm tm = to_tm(to_chrono(t));

Here are the necessary headers:

#include "date/date.h"
#include <chrono>
#include <ctime>

Or in C++20, just:

#include <chrono>
#include <ctime>