Using std::chrono in C

std::chrono is used in C to process time, including obtaining the current time, measuring execution time, operation time point and duration, and formatting analysis time. 1. Use std::chrono::system_clock::now() to obtain the current time, which can be converted into a readable string, but the system clock may not be monotonous; 2. Use std::chrono::steady_clock to measure the execution time to ensure monotonicity, and convert it into milliseconds, seconds and other units through duration_cast; 3. Time point (time_point) and duration (duration) can operate interoperably, but pay attention to the differences in unit compatibility and clock epoch; 4. C 20 supports time formatting and parsing, and needs to use std::format and std::parse, relying on the compiler's support for C 20.

Using std::chrono in C can be really useful once you get the hang of it. It's part of the standard library and give you solid tools for handling time — whether that's measuring durations, working with timestamps, or dealing with time zones in C 20 and beyond.

Getting the current time

To grab the current point in time, you usually go with std::chrono::system_clock::now() . That gives you a time_point representing right now.

 auto now = std::chrono::system_clock::now();

This is often used when you want to measure how long something takes or just log a timestamp. If you need to convert it to something readable like a string, you'll typically convert it to time_t and use ctime or similar:

 std::time_t now_c = std::chrono::system_clock::to_time_t(now);
std::cout << "Current time: " << std::ctime(&now_c);

Keep in mind that system_clock might not be monotonic — if someone changes the system time, it could jump forward or backward. For timing purposes, read on.

Measuring execution time accurately

When you want to measure how long a piece of code runs, steady_clock is your friend. It's monotonic (won't go backwards), which makes it safe for timing.

Here's a common pattern:

 auto start = std::chrono::steady_clock::now();

// ... do some work ...

auto end = std::chrono::steady_clock::now();
auto duration = end - start;

If you want to show this in millionseconds or seconds, you'll cast it using duration_cast :

 auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
std::cout << "Took " << ms << " ms\n";

You can also use microseconds , nanoseconds , or even seconds . Just keep in mind that converting from higher precision (like nanoseconds) to lower (like seconds) will truncate unless you cast properly.

Working with time points and durations

• A time_point is a specific moment.
• A duration is a span of time (like 5 seconds).

They're separate types, but they work together. You can add a duration to a time_point to get a new time_point:

 auto then = now std::chrono::hours(2);

This is handy when scheduling events or waiting until a certain time. Just make sure both sides of the operation are using compatible units — mixing hours and million seconds won't cause errors, but it might not do what you expect unless you explicitly convert.

Also, don't assume that all clocks start at zero — their epoch (starting point) varies:

• system_clock typically starts in 1970 (like Unix time).
• steady_clock has an arbitrary epoch, so comparing its time_points across runs doesn't make sense.

Formatting and parsing time (C 20 )

With C 20, <chrono> got better support for formatting dates and times directly:

 auto now = std::chrono::system_clock::now();
std::cout << "Formatted: " << std::format("{:%Y-%m-%d %H:%M}", now) << "\n";

Parsing time strings also became possible:

 std::istringstream ss("2024-03-15 12:30");
std::chrono::system_clock::time_point tp;
ss >> std::parse("%Y-%m-%d %H:%M", tp);

This is super helpful when reading logs or config files with timestamps. But remember, these features require C 20 and good compiler support (like GCC 13 , Clang 15 , or MSVC with latest STL).

So yeah, std::chrono is pretty powerful once you understand the basic types and when to use each clock. Not too hard, just a bit easy to mix up at first.

The above is the detailed content of Using std::chrono in C. For more information, please follow other related articles on the PHP Chinese website!