C ++：将Unix时间转换为非本地时区

Question

I am trying to convert a time held in a variable of time_t to a struct tm* in some time zone which is not the local time zone.

Building on this post , which discusses the inverse operation going from struct tm* to time_t , I have written the following function:

struct tm* localtime_tz(time_t* t, std::string timezone) {

  struct tm* ret;
  char* tz;

  tz = std::getenv("TZ"); // Store currently set time zone                                                                                                                           

  // Set time zone                                                                                                                                                                   
  setenv("TZ", timezone.c_str(), 1);
  tzset();

  std::cout << "Time zone set to " << std::getenv("TZ") << std::endl;

  ret = std::localtime(t); // Convert given Unix time to local time in time zone                                                                                                     
  std::cout << "Local time is: " << std::asctime(ret);
  std::cout << "UTC time is: " << std::asctime(std::gmtime(t));

  // Reset time zone to stored value                                                                                                                                                 
  if (tz)
    setenv("TZ", tz, 1);
  else
    unsetenv("TZ");
  tzset();

  return ret;

}

However, the conversion fails, and I get

Time zone set to CEST
Local time is: Wed Aug  9 16:39:38 2017
UTC time is: Wed Aug  9 16:39:38 2017

ie local time is set to UTC time, instead of UTC+2 for CEST.

Answer 1

The time zone abbreviations shown by date and other tools are not the names of time zones. The IANA time zone database uses a major city within the relevant region instead. The reason for that is that the abbreviations are not unique, and they do not convey sufficient information to convert past dates because places switch time zones.

In addition, POSIX specifies that the TZ variable has to be parsed in a specific way, and it pretty much suggests to treat a bare time zone abbreviation like UTC (but with a different abbreviation).

Instead, you have to use the actual time zone name, such as Europe/Berlin , or a POSIX time zone specifier such as CET-1CEST .

Answer 2

I'm providing an additional answer in case someone wants to do this in a way that is thread safe (without setting a global such as an environment variable). This answer requires C++11 (or better) and Howard Hinnant's free, open-source timezone library , which has been ported to linux, macOS and Windows.

This library builds on <chrono> , extending it to calendars and timezones. One can interface with the C timing API such as struct tm with this library, but such facilities aren't built in to the library. This library makes the C API unnecessary, unless you have to interface with other code that uses the C API.

For example there is a type called date::zoned_seconds that couples a system_clock::time_point (except with seconds precision) with a date::time_zone to create local time in an arbitrary time zone. As described in more detail here , here is how you can convert a zoned_seconds into a std::tm :

std::tm
to_tm(date::zoned_seconds tp)
{
    using namespace date;
    using namespace std;
    using namespace std::chrono;
    auto lt = tp.get_local_time();
    auto ld = floor<days>(lt);
    time_of_day<seconds> tod{lt - ld};  // <seconds> can be omitted in C++17
    year_month_day ymd{ld};
    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  = unsigned{ymd.month()} - 1;
    t.tm_year = int{ymd.year()} - 1900;
    t.tm_wday = unsigned{weekday{ld}};
    t.tm_yday = (ld - local_days{ymd.year()/jan/1}).count();
    t.tm_isdst = tp.get_info().save != minutes{0};
    return t;
}

Using this building block, it becomes almost trivial to convert a time_t to a tm in an arbitrary time zone (without setting a global):

std::tm
localtime_tz(time_t t, const std::string& timezone)
{
    using namespace date;
    using namespace std::chrono;
    return to_tm({timezone, floor<seconds>(system_clock::from_time_t(t))});
}

If you're using C++17, you can remove using namespace date as floor<seconds> will be completely provided within namespace std::chrono .

The above code creates a zoned_seconds from the string timezone and a system_clock::time_point derived from the time_t t . The zoned_seconds is conceptually a pair<time_zone, system_clock::time_point> but of arbitrary precision. And it can also be thought of as a pair<time_zone, local_time> since the time_zone knows how to map between UTC and local time. So most of the user-written code above is just in extracting the local time from the zoned_seconds and placing that into a struct tm .

The above code can be exercised like this:

auto tm = localtime_tz(time(nullptr), "America/Anchorage");

If you don't need the result in a tm but can instead stay within the <chrono> system, there exists very nice features in the timezone library for parsing and formatting the zoned_seconds , for example:

cout << zoned_seconds{"America/Anchorage", floor<seconds>(system_clock::now())} << '\n';

Sample output:

2017-08-10 16:50:28 AKDT