C++ Chrono

Time as a number with a unit

<chrono> gives you durations (how long) and clocks (when). A duration is an integer plus a unit: milliseconds, seconds, microseconds. You print the integer with count(). You do not print a wall-clock date in this chapter, so nothing depends on locale or timezone.

Include <chrono>. The names sit in std::chrono. Withusing namespace std; you write chrono::milliseconds. StudyGrid compiles this as C++17 with g++ 13.

milliseconds and count()

Construct a duration with a number of ticks. chrono::milliseconds wait(250) is 250 milliseconds.wait.count() returns that 250. The unit is in the type, not in the printed number, so label the output yourself if a person will read it.

#include <chrono>
#include <iostream>
using namespace std;

int main() {
  chrono::milliseconds pulse(250);
  chrono::seconds gap(3);
  cout << pulse.count() << endl;
  cout << gap.count() << endl;
  return 0;
}

Output is 250 then 3. Those are ticks in each type’s unit, not clock-face times.

duration_cast changes the unit

You cannot assign 2500 milliseconds to a chrono::seconds variable without saying how to convert. Integer conversion truncates toward zero: 2500 ms becomes 2 seconds, not 3. The tool ischrono::duration_cast<Target>(value).

#include <chrono>
#include <iostream>
using namespace std;

int main() {
  chrono::milliseconds raw(2500);
  chrono::seconds whole = chrono::duration_cast<chrono::seconds>(raw);
  cout << raw.count() << endl;
  cout << whole.count() << endl;
  return 0;
}

Output is 2500 then 2. The leftover 500 milliseconds are dropped. Cast the other way and 2 seconds become 2000 milliseconds with no loss.

Add durations of the same kind

Two milliseconds values add. The sum is still milliseconds. This is ordinary arithmetic on the tick counts, with the unit kept by the type.

#include <chrono>
#include <iostream>
using namespace std;

int main() {
  chrono::milliseconds a(120);
  chrono::milliseconds b(80);
  chrono::milliseconds sum = a + b;
  cout << sum.count() << endl;
  return 0;
}

Output is 200. Subtract the same way. Do not mix units until you duration_cast.

steady_clock around a loop

chrono::steady_clock is a clock that does not jump backward. Call now() before the work and after. Subtract the two time points. The difference is a duration. Cast it to a unit you want to print, then call count(). A tiny loop may be 0 milliseconds, so this example prints microseconds.

#include <chrono>
#include <iostream>
using namespace std;

int main() {
  auto started = chrono::steady_clock::now();
  long long total = 0;
  for (int i = 1; i <= 200000; i++) {
    total += i;
  }
  auto finished = chrono::steady_clock::now();
  auto us = chrono::duration_cast<chrono::microseconds>(finished - started);
  auto ms = chrono::duration_cast<chrono::milliseconds>(finished - started);
  cout << total << endl;
  cout << us.count() << endl;
  cout << ms.count() << endl;
  return 0;
}

The first line is the sum, which is fixed. The next two lines are elapsed microseconds and milliseconds. Those counts depend on the machine. Milliseconds of a short loop are often 0. That is expected: the cast truncates. This program does not sleep and does not start a thread.

Print durations, not dates

system_clock can represent calendar time. Formatting that as a date needs locale, timezones, and extra headers. Skip it here. If you need “how long did this take?”, prefer steady_clock and printcount() of a duration.

Keep measurements boring

Time a loop, a sort, or a function you already understand. Print the duration. Do not parse dates, and do not wait on another thread. Next: static, which is about shared data and values that survive from one call to the next, not about clocks.