home | help 
std::chrono::time_point(3)     C++ Standard Libary    std::chrono::time_point(3)

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 du-
     ration
	[static]	 (public static member function)

Non-member functions
	operator+			performs add and subtract operations in-
     volving 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, round-
     ing down
	(C++17) 		       (function template)
	ceil(std::chrono::time_point)  converts a time_point to another,  round-
     ing up
	(C++17) 		       (function template)
	round(std::chrono::time_point)	converts a time_point to another, round-
     ing to
	(C++17) 		       nearest, ties to even
				       (function template)

Helper classes
	std::common_type<std::chrono::time_point>  specializes	 the   std::com-
     mon_type trait
	(C++11) 				   (class  template  specializa-
     tion)
	std::hash<std::chrono::time_point>	      hash	support      for
     std::chrono::time_point
	(C++26) 				   (class  template  specializa-
     tion)

Example
     // Run this code

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

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

      int main()
      {
	  using namespace std::literals; // enables literal suffixes, e.g.  24h,
     1ms, 1s.

	  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();

	  std::cout << "Different clocks are not comparable: \n"
		       "  System time: " << now.time_since_epoch() << "\n"
		       "  Steady time: " << start.time_since_epoch() << '\n';

	  slow_motion();

	  const auto end = std::chrono::steady_clock::now();
	  std::cout
	      << "Slow calculations took "
	      <<   std::chrono::duration_cast<std::chrono::microseconds>(end   -
     start) << " a "
	      << (end - start) / 1ms << "ms a " // almost equivalent form of the
     above, but
	      << (end - start) / 1s << "s.\n";	// using milliseconds  and  sec-
     onds accordingly
      }

Possible output:
      24 hours ago, the time was 2021-02-15 18:28:52.
      Different clocks are not comparable:
	System time: 1666497022681282572ns
	Steady time: 413668317434475ns
      Slow calculations took 2090448A<micro>s a 2090ms a 2s.

See also
	duration       a time interval
	(C++11)        (class template)
	year_month_day represents a specific year, month, and day
	(C++20)        (class)

http://cppreference.com 	   2024.06.10	      std::chrono::time_point(3)
home | help