NAME

std::chrono::time_point - std::chrono::time_point

Synopsis

Defined in header <chrono>
template<

class Clock, (since C++11)
class Duration = typename Clock::duration

> class time_point;

Class template std::chrono::time_point represents a point in time. It is implemented
as if it stores a value of type Duration indicating the time interval from the start
of the Clock's epoch.

Clock must meet the requirements for Clock
or be std::chrono::local_t (until C++23)
(since C++20).

Member types

Member type Definition
clock Clock, the clock on which this time point is measured
duration Duration, a std::chrono::duration type used to measure the time since
epoch
rep Rep, an arithmetic type representing the number of ticks of the duration
period Period, a std::ratio type representing the tick period of the duration

Member functions

constructor constructs a new time point
(public member function)
time_since_epoch returns the time point as duration since the start of its clock
(public member function)
operator+= modifies the time point by the given duration
operator-= (public member function)
operator++
operator++(int) increments or decrements the duration
operator-- (public member function)
operator--(int)
(C++20)
min returns the time point corresponding to the smallest duration
[static] (public static member function)
max returns the time point corresponding to the largest duration
[static] (public static member function)

Non-member functions

operator+ performs add and subtract operations involving a time
operator- point
(C++11) (function template)
operator==
operator!=
operator<
operator<=
operator>
operator>=
operator<=> compares two time points
(C++11) (function template)
(C++11)(removed in C++20)
(C++11)
(C++11)
(C++11)
(C++11)
(C++20)
time_point_cast converts a time point to another time point on the
(C++11) same clock, with a different duration
(function template)
floor(std::chrono::time_point) converts a time_point to another, rounding down
(C++17) (function template)
ceil(std::chrono::time_point) converts a time_point to another, rounding up
(C++17) (function template)
round(std::chrono::time_point) converts a time_point to another, rounding to
(C++17) nearest, ties to even
(function template)

Helper classes

std::common_type<std::chrono::time_point> specializes the std::common_type trait
(C++11) (class template specialization)

Example

// Run this code

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <ctime>
#include <chrono>

void slow_motion()
{
static int a[] {1,2,3,4,5,6,7,8,9,10,11,12};
while (std::ranges::next_permutation(a).found)
{ } // generates 12! permutations
}

int main()
{
using namespace std::literals; // enables the usage of 24h, 1ms, 1s instead of
// e.g. std::chrono::hours(24), accordingly

const std::chrono::time_point<std::chrono::system_clock> now =
std::chrono::system_clock::now();

const std::time_t t_c = std::chrono::system_clock::to_time_t(now - 24h);
std::cout << "24 hours ago, the time was "
<< std::put_time(std::localtime(&t_c), "%F %T.\n") << std::flush;

const std::chrono::time_point<std::chrono::steady_clock> start =
std::chrono::steady_clock::now();

slow_motion();

const auto end = std::chrono::steady_clock::now();

std::cout
<< "Slow calculations took "
<< std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << "µs ≈ "
<< (end - start) / 1ms << "ms ≈ " // almost equivalent form of the above, but
<< (end - start) / 1s << "s.\n"; // using milliseconds and seconds accordingly
}

Possible output:

24 hours ago, the time was 2021-02-15 18:28:52.
Slow calculations took 2090448µs ≈ 2090ms ≈ 2s.