Converting time in milliseconds since epoch to time in yy-dd-hh-ss format-CodePudding

I have a bunch of tasks which are in the order of microseconds, the below code prints only until seconds (Thu Oct 21 12:48:20 2021) so comparing the values of start and finish always ends up giving 0. I want to be able to compare in the order of milliseconds and microseconds. Is there a function to help with this?

Also, is there a way to convert uint64_t current1 = std::chrono::system_clock::now().time_since_epoch().count(); to time_t to print out the current time based on the count()?

const auto p1 = std::chrono::system_clock::now();
    std::time_t now = std::chrono::system_clock::to_time_t(p1);
    std::cout << "now: " << std::ctime(&now);

CodePudding user response：

I recommend skipping the C timing API entirely. It is error-prone and doesn't handle sub-second precision.

If UTC (as opposed to local time) is ok, then there is a header-only, open-source preview of C 20 that works with C 11/14/17:

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

int
main()
{
    using date::operator<<;
    const auto p1 = std::chrono::system_clock::now();
    std::cout << "now: " << p1 << '\n';
}

Output:

now: 2021-10-21 20:28:15.754423

To port the above program to C 20 (which is already shipping in the latest Visual Studio), just drop the #include "date/date.h" and using date::operator<<;.

If you need local time, that can be also be had in C 20 (shipping in VS), but the open-source preview of C 20 is no longer header only. There exists one source file that needs to be compiled, and depending on your needs, might require a download of the IANA tz database.

#include "date/tz.h"
#include <chrono>
#include <iostream>

int
main()
{
    using namespace date;
    using namespace std::chrono;
    const auto p1 = system_clock::now();
    std::cout << "now: " << zoned_time{current_zone(), p1} << '\n';
}

Output:

now: 2021-10-21 16:28:15.754423 EDT

The above syntax assumes C 17. For C 11/14 the template parameter for zoned_time needs to be specified: zoned_time<system_clock::duration>.

The above program ports to C 20 by dropping #include "date/tz.h" and using namespace date;.

In either program you can truncate to millisecond precision with:

const auto p1 = floor<milliseconds>(system_clock::now());

CodePudding user response：

time_t is usually an integer specifying (whole) seconds.

You could get the millseconds by subtracting the whole-second time_t from now:

auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
              p1 - std::chrono::system_clock::from_time_t(now)).count();

or using operator%:

auto ms = std::chrono::time_point_cast<std::chrono::milliseconds>p1)
             .time_since_epoch() % std::chrono::seconds(1);

std::cout << ms.count();

Example how you could do the formatting:

#include <chrono>
#include <iostream>
#include <iomanip>

int main() {
    using Clock = std::chrono::system_clock;
    using Precision = std::chrono::milliseconds;

    auto time_point = Clock::now();

    // extract std::time_t from time_point
    std::time_t t = Clock::to_time_t(time_point);

    // output the part supported by std::tm
    std::cout << std::put_time(std::localtime(&t), "%FT%T."); // select format here

    // get duration since epoch
    auto dur = time_point.time_since_epoch();

    // extract the sub second part from the duration since epoch
    auto ss =
        std::chrono::duration_cast<Precision>(dur) % std::chrono::seconds{1};

    // output the millisecond part
    std::cout << std::setfill('0') << std::setw(3) << ss.count();
}