Chrono and Formatting

Durations and clocks

using namespace std::chrono_literals;

auto timeout = 250ms;
auto start = std::chrono::steady_clock::now();

• steady_clock: elapsed time and benchmarking.
• system_clock: wall-clock time.
• duration literals such as 10ms, 2s, and 5min improve readability.

Pick the clock by the question

• "How long did this take?" -> steady_clock
• "What time should the user see?" -> system_clock
• "Do I need calendar dates or time zones?" -> chrono calendar and zoned-time facilities

Quick clock comparison

• steady_clock: elapsed time, retries, timeouts, benchmarking
• system_clock: wall-clock timestamps, logs, user-visible times
• calendar and zoned time utilities: dates, local time presentation, timezone-aware output

Measuring elapsed time

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

auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);
std::cout << "work took " << ms.count() << " ms\n";

Converting durations

auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);

Use duration_cast when you need an explicit unit. Keep the original duration type if precision matters.

std::format and std::print

auto msg = std::format("{} took {} ms", name, ms.count());
std::print("{}\n", msg);

Formatting dates and times

auto now = std::chrono::system_clock::now();
auto text = std::format("{:%Y-%m-%d %H:%M}", now);

This is much easier to read and maintain than manually stitching together date fields.

Common format patterns

std::format("{:%H:%M:%S}", now);
std::format("{:%Y-%m-%d}", now);
std::format("elapsed = {} ms", ms.count());

Formatting your own types

If you format the same domain type repeatedly, consider defining a std::formatter specialization so logging and diagnostics stay consistent.

Practical guidance

• Use steady_clock for timeouts and measurements.
• Use system_clock for timestamps the user sees.
• Prefer std::format over hand-built stream chains when formatting gets nontrivial.

Quick decision guide

• use steady_clock for elapsed-time questions, retries, and timeout logic
• use system_clock for timestamps that represent real-world calendar time
• use calendar and zoned-time facilities only when local dates, clocks, or time zones actually matter
• keep raw durations until the reporting boundary, then cast to display units

Real-world pattern: measure and report

auto start = std::chrono::steady_clock::now();
run_job();
auto elapsed = std::chrono::steady_clock::now() - start;

std::print("job finished in {} ms\n",
		   std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());

Pitfalls worth remembering

• Do not use system_clock for elapsed-time measurement because wall-clock time can jump.
• Do not force everything into milliseconds too early if you still need finer precision.
• Prefer formatting APIs over manual string concatenation when the output has multiple fields or unit conversions.

Two common workflows

auto deadline = std::chrono::steady_clock::now() + 500ms;
while (std::chrono::steady_clock::now() < deadline) {
	if (poll_ready()) {
		break;
	}
}

Use this shape for timeout logic.

auto now = std::chrono::system_clock::now();
std::print("backup finished at {:%F %T}\n", now);

Use this shape for logs and user-visible timestamps.