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<3600,1>> hours;

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

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

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

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

typedef duration <Rep, ratio<1,1000000000>> 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};//3毫秒

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

    std::chrono::duration<double, std::ratio<1, 30>> 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 0;
}

 

時間間隔之間可以做運算，比如下面的例子中計算兩端時間間隔的差值：

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

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

    std::chrono::seconds t2( 60 );//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 0;
}

注意：我們還可以通過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<60 * 60 * 24>> 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 0;
}

 

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(24));
    std::time_t next = system_clock::to_time_t(now + std::chrono::hours(24));

    return 0;
}

 

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
// 2

    return 0;
}

 

可以利用 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
// 0
    
    return 0;
}