(原創)c++11中的日期和時間庫

　　c++11提供了日期時間相關的庫chrono，經過chrono相關的庫咱們能夠很方便的處理日期和時間。c++11還提供了字符串的寬窄轉換功能，也提供了字符串和數字的相互轉換的庫。有了這些庫提供的便利的工具類，咱們能方便的處理日期和時間相關的轉換和格式輸出。

chrono

　　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()，它的基本用法：

#include <chrono>
#include <iostream>
int main()
{
    std::chrono::milliseconds ms{3}; // 3 毫秒
    // 6000 microseconds constructed from 3 milliseconds
    std::chrono::microseconds us = 2*ms; //6000微秒
    // 30Hz clock using fractional ticks
    std::chrono::duration<double, std::ratio<1, 30>> hz30(3.5);
    std::cout <<  "3 ms duration has " << ms.count() << " ticks\n"<<  "6000 us duration has " << us.count() << " ticks\n"
}

輸出：
3 ms duration has 3 ticks
6000 us duration has 6000 ticks

         時間間隔之間能夠作運算，好比下面的例子中計算兩端時間間隔的差值：

std::chrono::minutes t1( 10 );
std::chrono::seconds t2( 60 );
std::chrono::seconds t3 = t1 - t2;
std::cout << t3.count() << " second" << std::endl;

         其中，t1 是表明 10 分鐘、 t2 是表明 60 秒，t3 則是 t1 減去 t2，也就是 600 - 60 = 540 秒。經過t1-t2的count輸出差值爲540個時鐘週期即540秒（由於每一個時鐘週期爲一秒）。咱們還能夠經過duration_cast<>()來將當前的時鐘週期轉換爲其它的時鐘週期，好比我能夠把秒的時鐘週期轉換爲分鐘的時鐘週期，而後經過count來獲取轉換後的分鐘時間間隔：

cout << chrono::duration_cast<chrono::minutes>( t3 ).count() <<」 minutes」<< endl;
將會輸出:
9 minutes

Time point

　　time_point表示一個時間點，用來獲取1970.1.1以來的秒數和當前的時間, 能夠作一些時間的比較和算術運算，能夠和ctime庫結合起來顯示時間。time_point必需要clock來計時，time_point有一個函數time_since_epoch()用來得到1970年1月1日到time_point時間通過的duration。下面的例子計算當前時間距離1970年1月一日有多少天：

#include <iostream>
#include <ratio>
#include <chrono>

int main ()
{
  using namespace std::chrono;
  typedef duration<int,std::ratio<60*60*24>> days_type;
  time_point<system_clock,days_type> today = time_point_cast<days_type>(system_clock::now());
  std::cout << today.time_since_epoch().count() << " days since epoch" << std::endl;
  return 0;
}

　　time_point還支持一些算術元算，好比兩個time_point的差值時鐘週期數，還能夠和duration相加減。下面的例子輸出前一天和後一天的日期：

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

int main()
{
    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));
    std::cout << "One day ago, the time was "<< std::put_time(std::localtime(&last), "%F %T") << '\n';
　　std::cout << "Next day, the time was "<< std::put_time(std::localtime(&next), "%F %T") << '\n';
}

輸出：

One day ago, the time was 2014-3-2622:38:27
Next day, the time was 2014-3-2822:38:27

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>

int main()
{
std::chrono::steady_clock::time_point t1 = std::chrono::system_clock::now();
std::cout << "Hello World\n";
std::chrono::steady_clock::time_point t2 = std::chrono:: system_clock::now();
std::cout << (t2-t1).count()<<」 tick count」<<endl;
}

輸出：

Hello World
20801tick count

         經過時鐘獲取兩個時間點之相差多少個時鐘週期，咱們能夠經過duration_cast將其轉換爲其它時鐘週期的duration：

cout << std::chrono::duration_cast<std::chrono::microseconds>( t2-t1 ).count() <<」 microseconds」<< endl;
輸出：
20 microseconds

         system_clock的to_time_t方法能夠將一個time_point轉換爲ctime：

std::time_t now_c = std::chrono::system_clock::to_time_t(time_point);

而from_time_t方法則是相反的，它將ctime轉換爲time_point。

　　steady_clock能夠獲取穩定可靠的時間間隔，後一次調用now()的值和前一次的差值是不由於修改了系統時間而改變，它保證了穩定的時間間隔。它的用法和system用法同樣。

時間的格式化輸出

　　system_clock和std::put_time配合起來使用能夠格式化日期的輸出，std::put_time能將日期格式化輸出。下面的例子是將當前時間格式化輸出：

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

int main()
{
    auto t = chrono::system_clock::to_time_t(std::chrono::system_clock::now());
cout<< std::put_time(std::localtime(&t), "%Y-%m-%d %X")<<endl;
cout<< std::put_time(std::localtime(&t), "%Y-%m-%d %H.%M.%S")<<endl;

    return 0;
}

上面的例子將輸出：

2014-3-27 22:11:49
2014-3-27 22.11.49

timer

　　能夠利用high_resolution_clock來實現一個相似於boost.timer的定時器，這樣的timer在測試性能時會常常用到，常常用它來測試函數耗時，它的基本用法是這樣的：

void fun()
{
    cout<<」hello word」<<endl;
}

int main()
{
         timer t; //開始計時
         fun()
         cout<<t.elapsed()<<endl; //打印fun函數耗時多少毫秒
}

　　c++11中增長了chrono庫，如今用來實現一個定時器是很簡單的事情，還能夠移除對boost的依賴。它的實現比較簡單，下面是具體實現：

#include<chrono>
usingnamespace std;
usingnamespace std::chrono;

classTimer
{
public:
    Timer() : m_begin(high_resolution_clock::now()) {}
    void reset() { m_begin = high_resolution_clock::now(); }

//默認輸出秒
　　double elapsed() const
　　{
　　　　return duration_cast<duration<double>>(high_resolution_clock::now() - m_begin).count();
　　}

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

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

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

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

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

    //時
    int64_t 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()
{
    cout<<」hello word」<<endl;
}

int main()
{
         timer t; //開始計時
         fun()
         cout<<t.elapsed()<<endl; //打印fun函數耗時多少毫秒
cout<<t.elapsed_micro ()<<endl; //打印微秒
cout<<t.elapsed_nano ()<<endl; //打印納秒
cout<<t.elapsed_seconds()<<endl; //打印秒
cout<<t.elapsed_minutes()<<endl; //打印分鐘
cout<<t.elapsed_hours()<<endl; //打印小時
}

 

若是你以爲這篇文章對你有用，能夠點一下推薦，謝謝。

c++11 boost技術交流羣：296561497，歡迎你們來交流技術。