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;

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  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;

Time point

time_point默示一个时候点,用来获取1970.1.1以来的秒数和当前的时候

可以做一些时候的斗劲和算术运算,可以和ctime库连络起来显示时候。

time_point必必要clock来计时,time_point有一个函数time__eproch()用来获得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:

std::chrono::duration_cast<std::chrono::microseconds>( t2-t1 ).count()
输出:
20 microseconds

system_clock的to_time_t办法可以将一个time_point转换为ctime:

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

时候的格局化输出

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>
using namespace std;
using namespace std::chrono;

classTimer
{

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

    //默认输出毫秒
    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; //打印小时
}