In this guide, we will explore the std::chrono::time_point in C++ along with an illustrative example.
A template class named std::chrono::time_point is provided in the <chrono> header of the C++ Standard Library. This class is employed for managing time-related calculations and signifies a specific moment in time.
Template Specifications:
Clock:
This particular moment in time is determined with the assistance of this clock function. Certain criteria need to be satisfied by the clock; otherwise (starting from C++20), it might be referred to as std::chrono::local_t.
Duration:
A std::chrono::duration type that measures the elapsed time since the clock's epoch started. It is optional, and if omitted, the clock's duration type will be employed by default.
Types of Members
Clock:
For the time-related clock, assign a nickname.
duration:
It serves as a type alias for the duration type, utilized in computing the epoch's duration.
It is a numerical representation that signifies the quantity of increments within the time span.
time frame:
It represents a form of std::ratio specifying the time interval's tick duration.
Member Functions
Constructor:
Create a new time instance by combining the provided clock time with the specified duration.
timesinceepoch:
It offers the duration of time measured from the initial clock reference point.
operator+= and operator-=:
It adjusts the timestamp by the designated time duration.
The operator++, operator++(int), operator--, and operator--(int) functions in C++20 are used for overloading the increment and decrement operators.
It increases or decreases the time frame.
min:
The function returns the time point that corresponds to the minimum duration possible.
max:
It offers the timestamp that aligns with the maximum achievable duration.
Non-Member Activities
operator+ and operator-.:
It performs addition and subtraction operations on time points.
The <, operator<=, operator> operator is used to compare two objects for equality. On the other hand, the <=> operator is utilized to determine if one object is greater than or equal to another object.
Two time points are compared.
timepointcast:
It transforms a specified time to another time with an altered duration on the identical clock.
floor(std::chrono::time_point) (C++17):
Round down and convert one time point to another.
ceil(std::chrono::time_point) (C++17):
Rounding up, convert one time point to another.
round(C++17) std::chrono::time_point:
Round a time point to the closest even number while simultaneously converting it to a different format.
Support Classes
std::commontype<std::chrono::timepoint> (C++11):
It customizes the std::commontype trait specifically for std::chrono::timepoint.
std::hash<std::chrono::time_point> (C++26):
It gives std::chrono::time_point hash support.
Example:1
Let's consider an example to demonstrate the std::chrono::time_point in the C++ programming language.
#include <iostream>
#include <iomanip>
#include <ctime>
#include <chrono>
using std::chrono::system_clock;
int main()
{
system_clock::time_point now = system_clock::now();
std::time_t now_c = system_clock::to_time_t(
now - std::chrono::hours(24 * 7)); // 7 days ago
std::cout << "Current date and time: "
<< std::put_time(std::localtime(&now_c), "%F %T") << '\n';
now_c = system_clock::to_time_t(now);
std::cout << "One week ago, the time was "
<< std::put_time(std::localtime(&now_c), "%F %T") << '\n';
}
Output:
Current date and time: 2023-11-04 17:16:09
One week ago, the time was 2023-10-28 17:16:09
Example:2
This illustration leverages <chrono> features to compute and display the elapsed time in microseconds.
#include <iostream>
#include <chrono>
using std::chrono::duration_cast;
using std::chrono::microseconds;
using std::chrono::steady_clock;
int main()
{
steady_clock::time_point start = steady_clock::now();
// Replace this block with the code you want to measure.
for (int i = 0; i < 1000000; ++i) {
// Some computation or operation.
}
steady_clock::time_point end = steady_clock::now();
std::cout << "Execution time: "
<< duration_cast<microseconds>(end - start).count()
<< " microseconds.\n";
}
Output:
Execution time: 7 microseconds.
