C++11中的日期和时间库

原文地址：http://www.nljb.net/default/C%2B%2B11%E4%B8%AD%E7%9A%84%E6%97%A5%E6%9C%9F%E5%92%8C%E6%97%B6%E9%97%B4%E5%BA%93/

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;

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; //打印小时
}

posted on 2016-11-22 15:05 ZhYQ_note 阅读(673) 评论(0) 收藏举报

刷新页面返回顶部

ZhYQ_note