C++ defines time formatting functions in terms of strftime
, which requires a struct tm
"broken-down time" record. However, the C and C++03 languages provide no thread-safe way to obtain such a record; there is just one master struct tm
for the whole program.
In C++03, this was more or less OK, because the language didn't support multithreading; it merely supported platforms supporting multithreading, which then provided facilities like POSIX localtime_r
.
C++11 also defines new time utilities, which interface with the non-broken-down time_t
type, which is what would be used to reinitialize the global struct tm
. But obtaining a time_t
isn't the problem.
Am I missing something or does this task still require reliance on POSIX?
EDIT: Here is some workaround code. It maintains compatibility with multithreaded environments that provide ::localtime_r
and single-threaded environments that provide only std::localtime
. It can easily be adapted to check for other functions as well, such as posix::localtime_r
or ::localtime_s
or what-have-you.
namespace query { char localtime_r( ... ); struct has_localtime_r { enum { value = sizeof localtime_r( std::declval< std::time_t * >(), std::declval< std::tm * >() ) == sizeof( std::tm * ) }; }; template< bool available > struct safest_localtime { static std::tm *call( std::time_t const *t, std::tm *r ) { return localtime_r( t, r ); } }; template<> struct safest_localtime< false > { static std::tm *call( std::time_t const *t, std::tm *r ) { return std::localtime( t ); } }; } std::tm *localtime( std::time_t const *t, std::tm *r ) { return query::safest_localtime< query::has_localtime_r::value >().call( t, r ); }
You're not missing anything.
The next C standard (due out probably this year) does have defined in Annex K:
struct tm *localtime_s(const time_t * restrict timer, struct tm * restrict result);
And this new function is thread safe! But don't get too happy. There's two major problems:
localtime_s
is an optional extension to C11.
C++11 references C99, not C11. local_time_s
is not to be found in C++11, optional or not.
Update
In the 4 years since I answered this question, I have also been frustrated by the poor design of C++ tools in this area. I was motivated to create modern C++ tools to deal with this:
http://howardhinnant.github.io/date/tz.html
#include "tz.h" #include <iostream> int main() { using namespace date; auto local_time = make_zoned(current_zone(), std::chrono::system_clock::now()); std::cout << local_time << '\n'; }
This just output for me:
2015-10-28 14:17:31.980135 EDT
local_time
is a pairing of std::chrono::system_clock::time_point
and time_zone
indicating the local time.
There exists utilities for breaking the std::chrono::system_clock::time_point
into human-readable field types, such as year, month, day, hour, minute, second, and subseconds. Here is a presentation focusing on those (non-timezone) pieces:
https://www.youtube.com/watch?v=tzyGjOm8AKo
All of this is of course thread safe (it is modern C++).
Update 2
The above is now part of C++20 with this slightly altered syntax:
#include <chrono> #include <iostream> int main() { namespace chr = std::chrono; chr::zoned_time local_time{chr::current_zone(), chr::system_clock::now()}; std::cout << local_time << '\n'; }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With