C++ ctime、chrono时间函数库

1、ctime

1.1、time_t time(time_t *t)函数

返回值：从1970-01-01 00:00:00 到系统当前时间所经过的时间以秒为单位
参数可为指向time_t的指针或者为nullptr，当参数不为空时，其返回值也存储于参数指针中

#include <ctime>

time_t seconds;
time(&seconds); //time_t time(time_t *t)
// seconds = time(nullptr) 和以上等同
cout << "从1970-01-01起的秒数 = " << seconds << "s" << endl;

运行结果：
从1970-01-01起的秒数 = 1580077542s

1.2、char *time = ctime(const time_t *timer)函数

将time_t类型的时间以字符串形式转换为当前时间

#include <ctime>

char *time = ctime(&seconds);//char *ctime(const time_t *timer)
// 字符串形式 day month year hours:minutes:seconds year\n\0
cout << "当前时间为：" << time;

运行结果：
当前时间为：Mon Jan 27 06:25:42 2020

1.3、struct tm *localtime(time_t *seconds)函数

将time_t类型的指针转换为tm结构的指针，tm结构如下所示

struct tm {
  int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61
  int tm_min;   // 分，范围从 0 到 59
  int tm_hour;  // 小时，范围从 0 到 23
  int tm_mday;  // 一月中的第几天，范围从 1 到 31
  int tm_mon;   // 月，范围从 0 到 11
  int tm_year;  // 自 1900 年起的年数
  int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起
  int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
  int tm_isdst; // 夏令时
}

#include <ctime>

struct tm *info = localtime(&seconds);
cout << info->tm_hour << "时 " << info->tm_min << "分 " << info->tm_sec << "秒" << endl;

运行结果：
6时 25分 42秒

1.4、clock_t clock(void)函数

返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。为了获取 CPU 所使用的秒数，通常需要除以CLOCKS_PER_SEC

#include <ctime>

clock_t start_t, end_t;
start_t = clock(); //clock_t clock(void) 
int i = 0;
while(i < 10000000){i++;}
end_t = clock();
cout << "程序段运行时间为：" << double(end_t - start_t)/CLOCKS_PER_SEC << "s" << endl;

运行结果：
程序段运行时间为：0.017s

2、chrono

chrono是方便时间日期操作的标准库，它既是相应的头文件名称，也是std命名空间下的一个子命名空间，所有时间日期相关定义均在std::chrono命名空间下。通过这个新的标准库，可以非常方便进行时间日期相关操作。
chrono库主要包含了三个概念：duration, time_point 和 clock。

2.1、Duration

时间范围表示
duration描述的是一段时间范围，比如10秒钟，两个小时，三个月…

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

模板类如上，通过数值（Rep）+单位（Period，即小时，分，秒）来进行表示时间范围（1小时），单位通过ratio来进行表示，模板类如下：

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

N为分子，D为分母，以N/D秒表示单位，如std::ratio<60,1>或std::ratio<60>为分钟，std::ratio<1:1000>为毫秒

std::chrono::duration<double, ratio<60,1>>  sec(1);     //一分钟
std::chrono::duration<double,ratio<60*60,1>>  hour(1);     //一小时

为了方便使用，在ratio头文件中定义了常用比率的别名：

  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;

在chrono库定义了如下的常用时间单位：

typedef duration<int64_t, nano>     nanoseconds;

typedef duration<int64_t, micro>    microseconds;

typedef duration<int64_t, milli>    milliseconds;

typedef duration<int64_t>       seconds

typedef duration<int, ratio< 60>>   minutes;

typedef duration<int, ratio<3600>>  hours;

因此，我们可以简单使用

std::chrono::seconds sec_1(1);
std::chrono::hours hour_1(1);

count
通过使用内部函数cout，我们可以得到这一段时间的数值

chrono::duration<double, ratio<60, 1>>  sec(1); //一分钟
chrono::duration<double, ratio<60*60, 1>> hour(1); //一小时
chrono::seconds sec_1(2);
chrono::hours hour_1(2);

cout << sec.count() << "分钟" << endl;
cout << sec_1.count() << "分钟" << endl;
cout << hour.count() << "小时" << endl;
cout << hour_1.count() << "小时" << endl;

运行结果：
1分钟
2分钟
1小时
2小时

运算操作

chrono::minutes min_1(8);
chrono::seconds sec_2(60);
chrono::seconds sec_3 = min_1 - sec_2;

cout << "相差时间：" << sec_3.count() << "秒" << endl;

运行结果：
相差时间：420秒

时间单位转换：duration_cast
为了方便我们对于不同单位时间的转化，chrono库提供了duration_cast类型转换函数。

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

//运算
    chrono::minutes min_1(8);
    chrono::seconds sec_2(60);
    chrono::seconds sec_3 = min_1 - sec_2;

    cout << "相差秒数：" << sec_3.count() << "秒" << endl;

    //duration_cast
    cout << "相差分钟：" << chrono::duration_cast<chrono::minutes>(sec_3).count() << "分钟" << endl;

运行结果:
相差秒数：420秒
相差分钟：7分钟

2.2、Time point

std::chrono::time_point 表示一个时间点，即一个时刻，如八点半。通过一个相对epoch的时间间隔duration来实现，epoch就是1970-1-1时刻，对于同一个时钟来说，所有的time_point的epoch都是固定的。这个类可以与标准库ctime结合起来显示时间，ctime内部的time_t类型就是代表这个秒数。

template<typename _Clock, typename _Dur = typename _Clock::duration>
class time_point{};

第一个参数为当前计时使用的时钟，可选为“system_colck”、“steady_colck”、“high_resolution_clock”或者是自定义的时钟类(参见2.3、Clock)；
第二个参数为时间间隔，默认为使用的时钟相同的间隔。
内部维护了一个duration私有成员，通过制定的时钟，来确定距离epoch时间点的间隔。

chrono::time_point <chrono::system_clock, chrono::duration<int>> tp_seconds (chrono::duration<int>(1));  //chrono::duration<int>(1)等价于chrono::duration<int, ratio<1>>(1) 即1秒

time_since_epoch
和1.1中time()函数相同，返回从1970-01-01 00:00:00 到系统当前时间所经过的时间，以秒为单位。

#include <chrono>
#include <ctime>
using namespace std;

chrono::system_clock::time_point tp = chrono::system_clock::now();
chrono::system_clock::duration dtn = tp.time_since_epoch();
time_t seconds = time(nullptr);

cout << "current time since epoch, expressed in:" << endl;
cout << "periods: " << dtn.count() << "system_clock periods" << endl;
cout << "seconds from chrono: " << dtn.count() * chrono::system_clock::period::num / chrono::system_clock::period::den << "s" << endl;
cout << "seconds from ctime: " << seconds << "s" << endl;

运行结果：
current time since epoch, expressed in:
periods: 1580218475125486266 system_clock periods
seconds from chrono: 1580218475s
seconds from ctime: 1580218475s

2.3、Clock

clock包含system_clock, steady_clock 和 high_resolution_clock，与time point 相关，用来表示时间点。

2.3.1、system_clock
system_clock从系统获取时钟
now：获取当前时刻
to_time_t:time_point转换为time_t类型
from_time_t:从time_t类型转换为time_point类型

chrono::duration<int,std::ratio<60*60*24> > one_day (1);

chrono::system_clock::time_point today = chrono::system_clock::now();
chrono::system_clock::time_point tomorrow = today + one_day;
time_t tt;

tt = chrono::system_clock::to_time_t (today);
cout << "today is: " << ctime(&tt);

tt = chrono::system_clock::to_time_t ( tomorrow );
cout << "tomorrow will be: " << ctime(&tt);

运行结果：
today is: Tue Jan 28 22:19:09 2020
tomorrow will be: Wed Jan 29 22:19:09 2020

2.3.2、steady_clock
steady_clock专门用于计算时间差的工具，steady_clock 类只有一个静态函数now(),用于获取当前的时间，计算时间差的方式如下：

chrono::steady_clock::time_point start = chrono::steady_clock::now();

int i = 0;
while(i < 1000000000) {i++;}

chrono::steady_clock::time_point end = chrono::steady_clock::now();

chrono::duration<double> dur = end - start;

cout << "程序段花费时间为： " << dur.count() << "s" << endl;

运行结果：
程序段花费时间为： 1.68736s

2.3.3、high_resolution_clock
high_resolution_clock是系统可用的最高精度的时钟。实际上high_resolution_clock只不过是system_clock或者steady_clock的typedef。

参考：菜鸟教程C++ 时间&日期
C++11 std::chrono库详解
Cplusplus
C++11标准库chrono库使用