c++11时间相关库(chrono)

以下整理自：https://www.2cto.com/kf/201404/290706.html

chrono 库主要包含了三种类型：时间间隔 Duration、时钟 Clocks 和时间点 Time point

duration：

duration 表示一段时间间隔，用来记录时间长度，可以表示几秒钟、几分钟或者几个小时的时间间隔

duration 的原型是：

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

第一个模板参数Rep是一个数值类型，表示时钟个数；第二个模板参数是一个默认模板参数std::ratio，它的原型是：

template<std::intmax_t Num, std::intmax_t Denom = 1> class ratio;

它表示每个时钟周期的秒数，其中第一个模板参数 Num 代表分子，Denom 代表分母，分母默认为 1，ratio 代表的是一个分子除以分母的分数值，比如 ratio<2> 代表一个时钟周期是两秒，ratio<60> 代表了一分钟，ratio<60*60> 代表一个小时，ratio<60*60*24> 代表一天。而ratio<1, 1000> 代表的则是1/1000秒即一毫秒，ratio<1, 1000000> 代表一微秒，ratio<1, 1000000000> 代表一纳秒。标准库为了方便使用，就定义了一些常用的时间间隔，如时、分、秒、毫秒、微秒和纳秒，在chrono命名空间下，它们的定义如下：

 typedef duration <Rep, ratio<,>> hours;

 typedef duration <Rep, ratio<,>> minutes;

 typedef duration <Rep, ratio<,>> seconds;

 typedef duration <Rep, ratio<,>> milliseconds;

 typedef duration <Rep, ratio<,>> microseconds;

 typedef duration <Rep, ratio<,>> nanoseconds;

通过定义这些常用的时间间隔类型，我们能方便的使用它们，比如线程的休眠：

std::this_thread::sleep_for(std::chrono::seconds(3)); //休眠三秒

std::this_thread::sleep_for(std::chrono:: milliseconds (100)); //休眠100毫秒

chrono 还提供了获取时间间隔的时钟周期个数的方法 count()

count 以及 duration 的基本用法：

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

 int main(void) {
     std::chrono::milliseconds ms{};//3毫秒

     std::chrono::microseconds us =  * ms;//6000微秒

     std::chrono::duration<double, std::ratio<, >> hz(3.5);
     //hz为3.5个周期时间长度，每个周期为1/30s

     cout << ms.count() << endl;//3 一个周期为1s
     cout << us.count() << endl;//6000 一个周期为1us
     cout << hz.count() << endl;//3.5

     return ;
 }

时间间隔之间可以做运算，比如下面的例子中计算两端时间间隔的差值：

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

 int main(void) {
     std::chrono::minutes t1();//10分钟

     std::chrono::seconds t2(  );//60秒

     std::chrono::seconds t3 = t1 - t2;

     //t3 的时间周期为 second
     std::cout << t3.count() << " second" << std::endl;

     //通过 duration_cast 将时间周期转化为 minutes
     cout << chrono::duration_cast<chrono::minutes>(t3).count() << " minutes" << endl;

 // 输出：
 // 540 second
 // 9 minutes

     return ;
 }

注意：我们还可以通过duration_cast<>() 来将当前的时钟周期转换为其它的时钟周期，如我可以把秒的时钟周期转换为分钟的时钟周期，然后通过 count 来获取转换后的分钟时间间隔

time point：

time_point 表示一个时间点，用来获取 1970.1.1 以来的秒数和当前的时间, 可以做一些时间的比较和算术运算，可以和 ctime 库结合起来显示时间。time_point 必须要 clock 来计时，time_point 有一个函数 time_from_eproch() 用来获得1970年1月1日到 time_point 时间经过的 duration。下面的例子计算当前时间距离1970年1月一日有多少天：

 #include <iostream>
 #include <ratio>
 #include <chrono>
 using namespace std;

 int main(void) {
     using namespace std::chrono;
     typedef duration<int, std::ratio< *  * >> day_type;

     time_point<system_clock, day_type> today = time_point_cast<day_type>(system_clock::now());
     cout << today.time_since_epoch().count() << " days since epoch" << endl;

 // 输出：
 // 17598 days since epoch

     return ;
 }

time_point还支持一些算术元算，比如两个time_point的差值时钟周期数，还可以和duration相加减。下面的例子输出前一天和后一天的日期：

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

 int main(void) {
     using namespace std::chrono;
     system_clock::time_point now = system_clock::now();//获得当前时间

     std::time_t last = system_clock::to_time_t(now - std::chrono::hours());
     std::time_t next = system_clock::to_time_t(now + std::chrono::hours());

     return ;
 }

clocks

表示当前的系统时钟，内部有 time_point, duration, Rep, Period 等信息，它主要用来获取当前时间，以及实现 time_t 和 time_point 的相互转换。Clocks包含三种时钟：

system_clock：从系统获取的时钟；

steady_clock：不能被修改的时钟；

high_resolution_clock：高精度时钟，实际上是 system_clock 或者 steady_clock 的别名

可以通过 now() 来获取当前时间点：

 #include <iostream>
 #include <chrono>
 #include <ratio>
 using namespace std;

 int main(void) {
     using namespace std::chrono;

     time_point<system_clock> t1 = system_clock::now();
     int cnt = 1e9;
     while(--cnt);
     time_point<system_clock> t2 = system_clock::now();

     cout << (t2 - t1).count() << endl;
     //通过 duration_cast<>() 将周期转化为 secondse
     cout << std::chrono::duration_cast<seconds>( t2-t1 ).count() << endl;

 // 输出：
 // 2669897000
 //

     return ;
 }

可以利用 high_resolution_clock 来实现一个类似于 boost.timer 的定时器：

 #include <iostream>
 #include <chrono>
 #define ll long long
 using namespace std;
 using namespace std::chrono;

 class Timer{
 public:
     Timer() : m_begin(high_resolution_clock::now()) {}
     //重置当前时间
     void reset() {
         m_begin = high_resolution_clock::now();
     }

     //默认输出毫秒
     ll elapsed() const {
         return duration_cast<chrono::milliseconds>(high_resolution_clock::now() - m_begin).count();
     }

     //微秒
     ll elapsed_micro() const {
         return duration_cast<chrono::microseconds>(high_resolution_clock::now() - m_begin).count();
     }

     //纳秒
     ll elapsed_nano() const {
         return duration_cast<chrono::nanoseconds>(high_resolution_clock::now() - m_begin).count();
     }

     //秒
     ll elapsed_seconds() const {
         return duration_cast<chrono::seconds>(high_resolution_clock::now() - m_begin).count();
     }

     //分
     ll elapsed_minutes() const {
         return duration_cast<chrono::minutes>(high_resolution_clock::now() - m_begin).count();
     }

     //时
     ll elapsed_hours() const {
         return duration_cast<chrono::hours>(high_resolution_clock::now() - m_begin).count();
     }

 private:
     time_point<high_resolution_clock> m_begin;

 };

 void fun(int n) {
     while(--n);
 }

 int main(void) {
     Timer t;//开始记时
     fun(1e9);
     cout << t.elapsed_nano() << endl;
     cout << t.elapsed_micro() << endl;
     cout << t.elapsed() << endl;
     cout << t.elapsed_seconds() << endl;
     cout << t.elapsed_minutes() << endl;
     cout << t.elapsed_hours() << endl;

 // 输出：
 // 2673899000
 // 2673899
 // 2674
 // 2
 // 0
 //

     return ;
 }