在C中使用std :: Chrono

std::chrono在C 中用於處理時間，包括獲取當前時間、測量執行時間、操作時間點與持續時間及格式化解析時間。 1. 獲取當前時間使用std::chrono::system_clock::now()，可轉換為可讀字符串但係統時鐘可能不單調；2. 測量執行時間應使用std::chrono::steady_clock以確保單調性，並通過duration_cast轉換為毫秒、秒等單位；3. 時間點(time_point)和持續時間(duration)可相互操作，但需注意單位兼容性和時鐘紀元(epoch)差異；4. C 20支持時間格式化與解析，需使用std::format和std::parse，依賴編譯器對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 gives 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 milliseconds 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 milliseconds 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.

以上是在C中使用std :: Chrono的詳細內容。更多資訊請關注PHP中文網其他相關文章！