std::chrono笔记

文章目录

- 1. radio
- - 原型
  - 作用
  - 示例
- 2. duration
- - 原型：
  - 作用
  - 示例
- 3. time_point
- - 原型
  - 作用
  - 示例
- 4. clocks
- - system_clock
  - - 示例
  - steady_clock
  - - 示例
  - high_resolution_clock

先说感觉，这个库真恶心，刚接触感觉跟shi一样，特别是那个命名空间，太长了。
就像这样：
在这里插入图片描述

后来感觉设计还挺巧妙，才觉得看起来顺眼一些。

1. radio

原型

template <intmax_t N, intmax_t D = 1> class ratio;

作用

时间换算的比率 / 表示时间精度。
ratio是一个比率的模板（分子/分母）。第一个模板参数是分子，第二个模板参数是分母，也可以只提供第一个，这样分母默认是0。主要用来表示精度、

可以把它当成一个分数，仅有ratio我们是做不了什么的。

示例

	ratio<60, 1> minute;
	ratio<1, 1> second;
	ratio<1, 1000> millisecond;

当然，头文件有预定义的例子，可以参考：

  typedef ratio<1,       1000000000000000000> atto;
  typedef ratio<1,          1000000000000000> femto;
  typedef ratio<1,             1000000000000> pico;
  typedef ratio<1,                1000000000> nano;
  typedef ratio<1,                   1000000> micro;
  typedef ratio<1,                      1000> milli;
  typedef ratio<1,                       100> centi;
  typedef ratio<1,                        10> deci;
  typedef ratio<                       10, 1> deca;
  typedef ratio<                      100, 1> hecto;
  typedef ratio<                     1000, 1> kilo;
  typedef ratio<                  1000000, 1> mega;
  typedef ratio<               1000000000, 1> giga;
  typedef ratio<            1000000000000, 1> tera;
  typedef ratio<         1000000000000000, 1> peta;
  typedef ratio<      1000000000000000000, 1> exa;

2. duration

原型：

template <class Rep, class Period = ratio<1> > class duration;

构造函数（想快点理解话，主要看第4个）：

(1)duration() = default;    //默认构造
(2)duration (const duration& dtn);        //(2)(3)拷贝构造
(3)template<class Rep2, class Period2>
   constexpr duration (const duration<Rep2,Period2>& dtn);
(4)template<class Rep2>      //传递一个某类型（int等）的数值，构造一个时间段   
   constexpr explicit duration (const Rep2& n);

作用

表示一段时间。
第一个模板参数Rep可以是int、float、double，第二个模板参数Period用来表示精度。Rep表示Period的数目。

duration模板中的方法count用来返回Period的数量，返回值是Rep类型。

不同类型的duration之间的转换用duration_cast<>，原型如下：

template <class ToDuration, class Rep, class Period>
constexpr ToDuration
duration_cast (const duration<Rep,Period>& dtn);

示例

#include <iostream>
#include <chrono>
#include <ctime>

using namespace std;
using namespace chrono;

int main (void)
{
	using seconds_type = duration<int, ratio<1, 1>>;
	using minutes_type = duration<int, ratio<60, 1>>;
	using hours_type = duration<int, ratio<3600, 1>>;
	using milliseconds_type = duration<int, ratio<1, 1000>>;
	
	seconds_type oneday_seconds (3600 * 24);
	hours_type oneday_hours (24);
	minutes_type oneday_minutes (60 * 24);
	milliseconds_type oneday_milliseconds (3600 * 24 * 1000);
	cout << "一天的秒数: " << oneday_seconds.count() << endl;
	cout << "一天的小时数: " << oneday_hours.count() << endl;
	cout << "一天的分钟数: " << oneday_minutes.count() << endl;
	cout << "一天的毫秒数: " << oneday_milliseconds.count() << endl;
	
	hours_type oneday_hours_from_milliseconds = duration_cast<hours_type> (oneday_milliseconds);
	hours_type oneday_hours_from_seconds = duration_cast<hours_type> (oneday_seconds);
	hours_type oneday_hours_from_miniues = duration_cast<hours_type> (oneday_minutes);
	cout << "转换后>>" << endl;
	cout << "一天的小时数：" << oneday_hours_from_milliseconds.count() << endl;
	cout << "一天的小时数：" << oneday_hours_from_seconds.count() << endl;
	cout << "一天的小时数：" << oneday_hours_from_miniues.count() << endl;
	
	cout << "一天的秒数：" << duration_cast<seconds_type> (oneday_milliseconds).count() << endl;
	cout << "一天的秒数：" << duration_cast<seconds_type> (oneday_minutes).count() << endl;
	cout << "一天的秒数：" << duration_cast<seconds_type> (oneday_hours).count() << endl;
	
	cout << "一天的毫秒数：" << duration_cast<milliseconds_type> (oneday_seconds).count() << endl;
	cout << "一天的毫秒数：" << duration_cast<milliseconds_type> (oneday_minutes).count() << endl;
	cout << "一天的毫秒数：" << duration_cast<milliseconds_type> (oneday_hours).count() << endl;
}

打印结果：

一天的秒数: 86400
一天的小时数: 24
一天的分钟数: 1440
一天的毫秒数: 86400000
转换后>>
一天的小时数：24
一天的小时数：24
一天的小时数：24
一天的秒数：86400
一天的秒数：86400
一天的秒数：86400
一天的毫秒数：86400000
一天的毫秒数：86400000
一天的毫秒数：86400000

也可以用头文件中预定义的：

    /// nanoseconds
    using nanoseconds	= duration<_GLIBCXX_CHRONO_INT64_T, nano>;
    /// microseconds
    using microseconds	= duration<_GLIBCXX_CHRONO_INT64_T, micro>;
    /// milliseconds
    using milliseconds	= duration<_GLIBCXX_CHRONO_INT64_T, milli>;
    /// seconds
    using seconds	= duration<_GLIBCXX_CHRONO_INT64_T>;
    /// minutes
    using minutes	= duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>>;
    /// hours
    using hours		= duration<_GLIBCXX_CHRONO_INT64_T, ratio<3600>>;
   ...
   ...

3. time_point

原型

template <class Clock, class Duration = typename Clock::duration>
  class time_point;

另外看一下system_clock中内容：

    struct system_clock
    {
      typedef chrono::nanoseconds				duration;
      typedef duration::rep					rep;
      typedef duration::period					period;
      typedef chrono::time_point<system_clock, duration> 	time_point;

		...

标准库有三种钟：system_clock，steady_clock和high_resolution_clock。

可以看出system_clock::time_point默认用的钟是system_clock，duration是纳秒级别的nanoseconds。

同时，为了转换不同的time_point，还提供了time_point_cast：

template <class ToDuration, class Clock, class Duration>
time_point<Clock,ToDuration>
time_point_cast (const time_point<Clock, Duration>& tp);

作用

表示时间点，一个time point必须有一个clock计时

示例

打印

	system_clock::time_point tp_epoch;
	
	time_point<system_clock, seconds> tp_seconds (seconds (1));
	time_point<
	//默认的time_point是纳米级：
	system_clock::time_point tp (tp_seconds);
	
	printf ("system_clock中，一秒对应%d个时钟周期\n",
			 tp.time_since_epoch().count() );
	
	system_clock::time_point
	time_t time = system_clock::to_time_t (tp);
	printf ("tp的打印结果：%s", ctime (&time));

打印结果：

system_clock中，一秒对应1000000000个时钟周期
tp的打印结果：Thu Jan  1 08:00:01 1970

转换

	using days_type = duration<int, ratio<3600 * 24>>;
	time_point<system_clock, days_type> today
	    = time_point_cast<days_type> (system_clock::now());
	printf ("从epoch到现在的天数: %d", today.time_since_epoch().count());

打印结果：

从epoch到现在的天数: 19415

到这里应该更能体会到，那个ratio<3600 * 24>，表示一个单位，int其实是单位的数量，整体看起来就是一段时间，只不过这段时间的精度是按天来算的，且数目是int类型。

4. clocks

system_clock

system_clock表示当前的系统时钟，系统中运行的所有进程使用now()得到的时间是一致的。
每一个clock类中都有确定的time_point, duration, Rep, Period类型。
操作有：

now()
- 当前时间time_point
to_time_t()
- 将 time_point转换成time_t秒
from_time_t()
- 从time_t转换成time_poin

示例

计算时间日期

#include <iostream>
#include <chrono>
#include <ctime>
#include <fmt/format.h>

using namespace std;
using namespace chrono;

int main (void)
{
	using days_type = duration<int, ratio<3600 * 24>>;
	days_type one_day (1);
	
	system_clock::time_point today = system_clock::now();
	system_clock::time_point tomorrow = today + one_day;
	
	time_t time = system_clock::to_time_t (today);
	printf ("今天是：%s", ctime (&time));
	time = system_clock::to_time_t (tomorrow);
	printf ("明天是：%s", ctime (&time));
}

steady_clock

steady_clock 为了表示稳定的时间间隔，后一次调用now()得到的时间总是比前一次的值大（这句话的意思其实是，如果中途修改了系统时间，也不影响now()的结果），每次tick都保证过了稳定的时间间隔。
操作有：

now()
- 获取当前时钟

示例

典型的应用是给算法计时。

#include <iostream>
#include <chrono>
#include <ctime>
#include <fmt/format.h>

using namespace std;
using namespace chrono;

int main (void)
{
	steady_clock::time_point t1 = steady_clock::now();
	cout << "打印1000个 *" << endl;
	
	for (int i = 0; i < 1000; ++i)
		cout << "*";
	cout << endl;
	steady_clock::time_point t2 = steady_clock::now();
	
	duration<double> time = duration_cast<duration<double>> (t2 - t1);
	cout << "花费的秒数：" << time.count() << endl;
}

*************************************...
花费的秒数：9.3816e-05

high_resolution_clock

最后一个时钟，high_resolution_clock 顾名思义，这是系统可用的最高精度的时钟。实际上high_resolution_clock只不过是system_clock或者steady_clock的typedef。
操作有：

now()
- 获取当前时钟。

参考博客：

C++11 std::chrono库详解

c++11 chrono全面解析(最高可达纳秒级别的精度)