Chrono in C++

Chrono is a C++ header that contains a set of time-related classes and methods. It is part of the C++ Standard Template Library (STL) and is included in C++11 along with subsequent versions.

<Chrono> supports three sorts of clocks: system_clock, steady_clock, and high_resolution_clock. These clocks are utilized for measuring time in a variety of ways.

system_clock is the system-wide real-time wall clock. The system's time adjustments influence it.
steady_clock represents a monotonically growing clock that is not impacted by modifications to the system time.
high_resolution_clock is the system's internal clock with the smallest tick period.

<chrono> includes a variety of duration types, such as duration <Rep, Period>, that can be used to describe a period. Rep is the kind of representation (such as int or long), and Period is the time ratio (such as microseconds or seconds).

Furthermore, <chrono> includes a set of time point types, such as time_pointClock, Duration>, that may be utilized to describe a point in time. The clock is the clock type (for example, system_clock), and Duration is the period type (for example, seconds).

The Chrono library is used to manage dates and times. This library was created to deal with the reality that timers and clocks may differ between systems to improve precision over time. The distinguishing feature of chrono is that it provides a precision-neutral concept by decoupling duration and time point ("timepoint") from individual clocks. The name chrono refers to both a header and a sub-namespace: Except for the common_type specializations, all of the components in this header have been defined in the std::chrono namespace rather than the std namespace (as is the case with the majority of the standard library). This header's elements are concerned with time. It can be achieved mostly through the use of three concepts.

Duration

A duration object represents a period using a count such as a minute, two hours, or ten milliseconds. For example, "48seconds" could have been represented as 48 ticks within a 1-second time unit.

Filename: Duration_count.c

// Program for using Chrono header file
#include <iostream> 
#include <chrono>	 
int main ()
{
	using namespace std::chrono;

	milliseconds milli(1000); 
	
	milli = milli*60;
	
	std::cout << "The duration (in periods): ";
	std::cout << milli.count() << " the time in milliseconds.\n";
	
	std::cout << "The duration (in seconds): ";
	std::cout << (milli.count() * milliseconds::period::num / 
							milliseconds::period::den);
	std::cout << " seconds.\n";

	return 0;
}

Output:

The duration (in periods): 60000 the time in milliseconds.
The duration (in seconds): 60 seconds.

Clock

A clock comprises a beginning point (epoch) and a tick rate. For example, a clock could have an epoch of February 22, 1997, tick every second. C++ defines three types of clocks:

system_clock- It is the time at the moment according to the system (the ordinary clock we see on the system's toolbar). The syntax is std::chrono::system_clock.
steady_clock- It's a static clock that will never be altered. It moves at a consistent rate. The syntax is std::chrono::steady_clock.
high_resolution_clock- It has the shortest tick period conceivable. It's formatted as-std::chrono::high_resolution_clock.

Point in time

A time_point object represents a point in time relative to the epoch of a clock. Internally, the object maintains a duration-type object that refers to the Clock type.

Filename: Systemclock.c

// C++ application describe time point // and system clock methods
#include <iostream>
#include <chrono>
#include <ctime>

// function for calculating the Fibonacci series
long fib(unsigned num)
{
	if (num < 2) return num;
	return fib(num-1) + fib(num-2);
}

int main()
{
	
	std::chrono::time_point<std::chrono::system_clock> start, end;

	start = std::chrono::system_clock::now();
	std::cout << "f(45) = " << fib(45) << '\n';
	end = std::chrono::system_clock::now();

	std::chrono::duration<double> elapsed_seconds = end - start;
	std::time_t end_time = std::chrono::system_clock::to_time_t(end);

	std::cout << "The finished computation is at " << std::ctime(&end_time)
			<< "The elapsed time is: " << elapsed_seconds.count() << "s\n";
}

Output:

f(45) = 1134903170
The finished computation is at Mon Oct 9 16:15:36 2023
The elapsed time is 9.89949s

It's necessary to note that the precision and accuracy of the clocks and durations offered by <chrono> may vary according to the system and platform; therefore, check your platform's specifications for additional information.

Next TopicCount Smaller Elements on Right Side in C++

← prev next →