Boost C++ 库

世界上最受推崇和设计最精良的 C++ 库项目之一。 — Herb Sutter 和 Andrei Alexandrescu, C++ Coding Standards

Posix 时间 - Boost C++ 函数库
PrevUpHomeNext

Posix 时间

Ptime
时间间隔
时间周期
时间迭代器

Posix 时间系统

引言 -- 使用示例

引言

定义了一个具有纳秒/微秒分辨率和稳定计算特性的非调整时间系统。纳秒分辨率选项使用 96 位底层存储表示每个 ptime，而微秒分辨率使用 64 位每 ptime（有关详细信息，请参阅 Build-Compiler Information）。此时间系统使用格里高利历来实现时间表示的日期部分。

使用示例

示例 描述
时间数学 使用 ptime 和 time_durations 进行的一些简单计算。
打印小时 从时钟检索时间，使用 time_iterator。
本地时间转 UTC 演示了将本地时间转换为 UTC 时间的几种不同方法，包括夏令时规则。
时间周期 时间周期的交集和显示的一些简单示例。

Ptime

引言 -- 头文件 -- 构造 -- 从字符串构造 -- 从时钟构造 -- 使用转换函数构造 -- 访问器 -- 转换为字符串 -- 运算符 -- struct tm, time_t, and FILETIME 函数

引言

boost::posix_time::ptime 类是时间点操作的主要接口。通常，ptime 类一旦构造就不可变，但允许赋值。

ptime 类依赖于 gregorian::date 来获取时间点的日期部分接口。

创建时间的其他技术包括 时间迭代器。

头文件

#include "boost/date_time/posix_time/posix_time.hpp" //include all types plus i/o
or
#include "boost/date_time/posix_time/posix_time_types.hpp" //no i/o just types

构造

语法 描述
示例
 
ptime(date,time_duration)
 从日期和偏移量构造 
ptime t1(date(2002,Jan,10), 
         time_duration(1,2,3));
ptime t2(date(2002,Jan,10), 
         hours(1)+nanosec(5));
ptime(ptime)
 复制构造函数 
ptime t3(t1)
ptime(special_values sv)
 用于无穷大、非日期时间、最大日期时间和最小日期的构造函数 
ptime d1(neg_infin);
ptime d2(pos_infin);
ptime d3(not_a_date_time);
ptime d4(max_date_time);
ptime d5(min_date_time);
ptime;
 默认构造函数。创建并初始化为 not_a_date_time 的 ptime 对象。注意：通过定义 DATE_TIME_NO_DEFAULT_CONSTRUCTOR（请参阅 compiler_config.hpp）可以禁用此构造函数。 
ptime p; // p => not_a_date_time

从字符串构造

语法 描述
示例
 
ptime time_from_string(std::string)
 从分隔字符串。注意：小数秒中多余的数字将被丢弃。例如，“1:02:03.123456999”=> 1:02:03.123456。此行为受库编译精度（请参阅 Build-Compiler Information）的影响。 
std::string ts("2002-01-20 23:59:59.000");
ptime t(time_from_string(ts))
ptime from_iso_string(std::string)
 从非分隔的 ISO 8601 格式字符串。 
std::string ts("20020131T235959");
ptime t(from_iso_string(ts))
ptime from_iso_extended_string(std::string)
 从分隔的 ISO 8601 格式字符串。 
std::string ts("2020-01-31T23:59:59.123");
ptime t(from_iso_extended_string(ts))

从时钟构造

语法 描述
示例
 
ptime second_clock::local_time()
 获取本地时间，秒级分辨率，基于计算机的时区设置。 
ptime t(second_clock::local_time());
ptime second_clock::universal_time()
 获取 UTC 时间。 
ptime t(second_clock::universal_time())
ptime microsec_clock::local_time()
 使用亚秒分辨率时钟获取本地时间。在 Unix 系统上，使用 gettimeofday 实现。在大多数 Win32 平台上，使用 ftime 实现。Win32 系统通过此 API 通常无法达到微秒分辨率。如果高分辨率对您的应用程序至关重要，请测试您的平台以了解实际达到的分辨率。 
ptime t(microsec_clock::local_time());
ptime microsec_clock::universal_time()
 使用亚秒分辨率时钟获取 UTC 时间。在 Unix 系统上，使用 gettimeofday 实现。在大多数 Win32 平台上，使用 ftime 实现。Win32 系统通过此 API 通常无法达到微秒分辨率。如果高分辨率对您的应用程序至关重要，请测试您的平台以了解实际达到的分辨率。 
ptime t(microsec_clock::universal_time());

使用转换函数构造

语法 描述
示例
 
ptime from_time_t(time_t t);
 将 time_t 转换为 ptime。 
ptime t = from_time_t(tt);
ptime from_ftime<ptime>(FILETIME ft);
 从 FILETIME 结构创建 ptime 对象。 
ptime t = from_ftime<ptime>(ft);

访问器

语法 描述
示例
 
date date()
 获取时间的日期部分。 
date d(2002,Jan,10);
ptime t(d, hour(1));
t.date() --> 2002-Jan-10;
time_duration time_of_day()
 获取一天中的时间偏移量。 
date d(2002,Jan,10);
ptime t(d, hour(1));
t.time_of_day() --> 01:00:00;
bool is_infinity() const
 如果 ptime 是正无穷大或负无穷大，则返回 true。 
ptime pt(pos_infin); 
pt.is_infinity(); // --> true
bool is_neg_infinity() const
 如果 ptime 是负无穷大，则返回 true。 
ptime pt(neg_infin);
pt.is_neg_infinity(); // --> true
bool is_pos_infinity() const
 如果 ptime 是正无穷大，则返回 true。 
ptime pt(neg_infin); 
pt.is_pos_infinity(); // --> true
bool is_not_a_date_time() const
 如果值不是 ptime，则返回 true。 
ptime pt(not_a_date_time);
pt.is_not_a_date_time(); // --> true
bool is_special() const
 如果 ptime 是任何 special_value，则返回 true。 
ptime pt(pos_infin); 
ptime pt2(not_a_date_time); 
ptime pt3(date(2005,Mar,1), hours(10));
pt.is_special(); // --> true
pt2.is_special(); // --> true
pt3.is_special(); // --> false

转换为字符串

语法 描述
示例
 
std::string to_simple_string(ptime)
 转换为 YYYY-mmm-DD HH:MM:SS.fffffffff 字符串，其中 mmm 是 3 个字符的月份名称，只有在非零时才包含小数秒。 
2002-Jan-01 10:00:01.123456789
std::string to_iso_string(ptime)
 转换为 YYYYMMDDTHHMMSS.fffffffff 格式，其中 T 是日期时间分隔符，只有在非零时才包含小数秒。 
20020131T100001.123456789
std::string to_iso_extended_string(ptime)
 转换为 YYYY-MM-DDTHH:MM:SS.fffffffff 格式，其中 T 是日期时间分隔符，只有在非零时才包含小数秒。 
2002-01-31T10:00:01.123456789

运算符

语法 描述
示例
 
operator<<, operator>>
 流运算符。注意：自 1.33 版本以来，流操作得到了极大的改进。有关更多详细信息（包括异常和错误条件），请参阅 Date Time IO System。 
ptime pt(not_a_date_time);
stringstream ss("2002-Jan-01 14:23:11");
ss >> pt; 
std::cout << pt; // "2002-Jan-01 14:23:11"
  
operator==, operator!=,
operator>, operator<,
operator>=, operator<=
 完整的比较运算符集。 
t1 == t2, etc
ptime operator+(days)
 返回一个 ptime，并加上一天偏移量。 
date d(2002,Jan,1);
ptime t(d,minutes(5));
days dd(1);
ptime t2 = t + dd;
ptime operator-(days)
 返回一个 ptime，并减去一天偏移量。 
date d(2002,Jan,1);
ptime t(d,minutes(5));
days dd(1);
ptime t2 = t - dd;
ptime operator+(time_duration)
 返回一个 ptime，并加上一个时间间隔。 
date d(2002,Jan,1);
ptime t(d,minutes(5));
ptime t2 = t + hours(1) + minutes(2);
ptime operator-(time_duration)
 返回一个 ptime，并减去一个时间间隔。 
date d(2002,Jan,1);
ptime t(d,minutes(5));
ptime t2 = t - minutes(2);
time_duration operator-(ptime)
 计算两个时间之间的差值。 
date d(2002,Jan,1);
ptime t1(d,minutes(5));
ptime t2(d,seconds(5));
time_duration t3 = t2 - t1;//negative result

struct tm, time_t, and FILETIME 函数

提供了将 posix_time 对象转换为 tm 结构以及从 tm 结构转换的功能，还提供了从 time_t 和 FILETIME 转换的功能。

语法 描述
示例
 
tm to_tm(ptime)
 一个将 ptime 对象转换为 tm 结构的函数。tm_isdst 字段设置为 -1。 
ptime pt(date(2005,Jan,1), time_duration(1,2,3));
tm pt_tm = to_tm(pt);
/* tm_year => 105
   tm_mon  => 0
   tm_mday => 1
   tm_wday => 6 (Saturday)
   tm_yday => 0
   tm_hour => 1
   tm_min  => 2
   tm_sec  => 3
   tm_isdst => -1 */
ptime ptime_from_tm(tm timetm)
 一个将 tm 结构转换为 ptime 对象的函数。tm_wday、tm_yday 和 tm_isdst 字段被忽略。 
tm pt_tm;
pt_tm.tm_year = 105;
pt_tm.tm_mon  = 0;
pt_tm.tm_mday = 1;
pt_tm.tm_hour = 1;
pt_tm.tm_min  = 2;
pt_tm.tm_sec  = 3;
ptime pt = ptime_from_tm(pt_tm);
// pt => 2005-Jan-01 01:02:03
tm to_tm(time_duration)
 一个将 time_duration 对象转换为 tm 结构的函数。tm_year、tm_mon、tm_mday、tm_wday、tm_yday 字段设置为零。tm_isdst 字段设置为 -1。 
time_duration td(1,2,3);
tm td_tm = to_tm(td);
/* tm_year => 0
   tm_mon  => 0
   tm_mday => 0
   tm_wday => 0
   tm_yday => 0
   tm_hour => 1
   tm_min  => 2
   tm_sec  => 3
   tm_isdst => -1 */
ptime from_time_t(std::time_t)
 从 time_t 参数创建 ptime。time_t 中包含的秒数将加到 1970 年 1 月 1 日的时间点上。 
ptime pt(not_a_date_time);
std::time_t t;
t = 1118158776;
pt = from_time_t(t);
// pt => 2005-Jun-07 15:39:36
ptime from_ftime<ptime>(FILETIME)
 一个从 FILETIME 结构构造 ptime 的模板函数。 
FILETIME ft;
ft.dwHighDateTime = 29715317;
ft.dwLowDateTime = 3865122988UL;
ptime pt = from_ftime<ptime>(ft);
// pt => 2005-Jun-07 15:30:57.039582000

时间间隔

引言 -- 头文件 -- 构造 -- 基于计数构造 -- 从字符串构造 -- 访问器 -- 转换为字符串 -- 运算符 -- struct tm 函数

引言

boost::posix_time::time_duration 类是表示时间长度的基本类型。时间间隔可以是正的也可以是负的。通用的 time_duration 类提供了一个构造函数，该构造函数接受小时、分钟、秒和小数秒的计数，如下面的代码片段所示。time_duration 的分辨率可在编译时配置。有关更多信息，请参阅 Build-Compiler Information。

using namespace boost::posix_time;
time_duration td(1,2,3,4); //01:02:03.000000004 when resolution is nano seconds
time_duration td(1,2,3,4); //01:02:03.000004 when resolution is micro seconds

几个小的辅助类派生自 base time_duration，如下图所示，用于调整不同的分辨率。这些类可以缩短代码并使意图更清晰。

举个例子

using namespace boost::posix_time;
      
time_duration td = hours(1) + seconds(10); //01:00:10
td = hours(1) + nanoseconds(5); //01:00:00.000000005

请注意，高分辨率类（例如纳秒）的存在取决于库的安装。有关更多信息，请参阅 Build-Compiler Information。

处理此问题的另一种方法是利用 time_duration 的 ticks_per_second() 方法来编写代码，使其具有可移植性，无论库如何编译。计算独立于分辨率的计数的通用公式如下：

count*(time_duration_ticks_per_second / count_ticks_per_second)

例如，假设我们想使用表示十分之一秒的计数来构造。也就是说，每个刻度是 0.1 秒。

int number_of_tenths = 5;
//create a resolution independent count -- divide by 10 since there are 
//10 tenths in a second.  
int count = number_of_tenths*(time_duration::ticks_per_second()/10);
time_duration td(1,2,3,count); //01:02:03.5 //no matter the resolution settings

头文件

#include "boost/date_time/posix_time/posix_time.hpp" //include all types plus i/o
or
#include "boost/date_time/posix_time/posix_time_types.hpp" //no i/o just types

构造

语法 描述
示例
 
time_duration(hours,
              minutes,
              seconds,
              fractional_seconds)
 从计数构造一个时间间隔。fractional_second 参数是一个单位数，因此会受到应用程序编译时分辨率的影响（请参阅 Build-Compiler Information）。如果 fractional_seconds 参数超过了编译精度限制，则多余的值将被“进位”到秒字段。有关创建独立于分辨率的计数的技巧，请参阅上文。 
time_duration td(1,2,3,9);
//1 hr 2 min 3 sec 9 nanoseconds
time_duration td2(1,2,3,123456789);
time_duration td3(1,2,3,1000);
// with microsecond resolution (6 digits)
// td2 => "01:04:06.456789"
// td3 => "01:02:03.001000"
// with nanosecond resolution (9 digits)
// td2 => "01:02:03.123456789"
// td3 => "01:02:03.000001000"
time_duration(special_value sv)
 特殊值构造函数。重要提示：当 time_duration 是一个特殊值（通过构造或任何其他方式）时，以下访问器函数将产生不可预测的结果。
hours(), minutes(), seconds(), ticks(), 
fractional_seconds(), total_nanoseconds(),
total_microseconds(), total_milliseconds(),
total_seconds()
其余的访问器函数将按预期工作。

基于计数构造

语法 描述
示例
 
hours(long)
 小时数 
time_duration td = hours(3);
minutes(long)
 分钟数 
time_duration td = minutes(3);
seconds(long)
 秒数 
time_duration td = seconds(3);
milliseconds(long)
 毫秒数。 
time_duration td = milliseconds(3);
microseconds(long)
 微秒数。 
time_duration td = microseconds(3);
nanoseconds(long)
 纳秒数。 
time_duration td = nanoseconds(3);

从字符串构造

语法 描述
示例
 
time_duration duration_from_string(std::string)
 从分隔字符串。注意：小数秒中多余的数字将被丢弃。例如，“1:02:03.123456999”=> 1:02:03.123456。此行为受库编译精度（请参阅 Build-Compiler Information）的影响。 
std::string ts("23:59:59.000");
time_duration td(duration_from_string(ts));

访问器

语法 描述
示例
 
boost::int64_t hours()
 获取标准化的小时数（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3); 
time_duration neg_td(-1,2,3);
td.hours(); // --> 1
neg_td.hours(); // --> -1
boost::int64_t minutes()
 获取标准化分钟数 +/-(0..59)（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3);
time_duration neg_td(-1,2,3);
td.minutes(); // --> 2
neg_td.minutes(); // --> -2
boost::int64_t seconds() const
 获取标准化秒数 +/-(0..59)（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3); 
time_duration neg_td(-1,2,3);
td.seconds(); // --> 3
neg_td.seconds(); // --> -3
boost::int64_t total_seconds() const
 获取总秒数，截断任何小数秒（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3,10);
td.total_seconds(); 
// --> (1*3600) + (2*60) + 3 == 3723
boost::int64_t total_milliseconds() const
 获取总毫秒数，截断任何剩余数字（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3,123456789);
td.total_milliseconds(); 
// HMS --> (1*3600) + (2*60) + 3 == 3723 seconds
// milliseconds is 3 decimal places
// (3723 * 1000) + 123 == 3723123
boost::int64_t total_microseconds() const
 获取总微秒数，截断任何剩余数字（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3,123456789);
td.total_microseconds(); 
// HMS --> (1*3600) + (2*60) + 3 == 3723 seconds
// microseconds is 6 decimal places
// (3723 * 1000000) + 123456 == 3723123456
boost::int64_t total_nanoseconds() const
 获取总纳秒数，截断任何剩余数字（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3,123456789);
td.total_nanoseconds(); 
// HMS --> (1*3600) + (2*60) + 3 == 3723 seconds
// nanoseconds is 9 decimal places
// (3723 * 1000000000) + 123456789
//                              == 3723123456789
boost::int64_t fractional_seconds() const
 获取小数秒数（如果调用的 time_duration 是 special_value，则结果将不可预测）。 
time_duration td(1,2,3, 1000);
td.fractional_seconds(); // --> 1000
bool is_negative() const
 当且仅当时间间隔为负时，返回 true。 
time_duration td(-1,0,0); 
td.is_negative(); // --> true
bool is_zero() const
 当且仅当时间间隔为零时，返回 true。 
time_duration td(0,0,0);
td.is_zero(); // --> true
bool is_positive() const
 当且仅当时间间隔为正时，返回 true。 
time_duration td(1,0,0);
td.is_positive(); // --> true
time_duration invert_sign() const
 生成一个符号相反的时间间隔。 
time_duration td(-1,0,0);
td.invert_sign(); // --> 01:00:00
time_duration abs() const
 生成一个时间间隔绝对值的新时间间隔。 
time_duration td(-1,0,0);
td.abs(); // --> 01:00:00
 
time_duration td(+1,0,0);
td.abs(); // --> 01:00:00
 
date_time::time_resolutions time_duration::resolution()
 描述 time_duration 类的分辨率能力。time_resolutions 是一个枚举类型，包含从秒到纳秒的分辨率可能性。   
time_duration::resolution() --> nano
   
unsigned short time_duration::num_fractional_digits()
 返回时间分辨率的小数位数。   
unsigned short secs;
secs = time_duration::num_fractional_digits();
// 9 for nano, 6 for micro, etc.
   
boost::int64_t time_duration::ticks_per_second()
 返回每秒的刻度数。例如，如果时间间隔支持纳秒，则返回结果将是 1,000,000,000 (1e+9)。   
std::cout << time_duration::ticks_per_second();
   
boost::int64_t ticks()
 返回时间间隔类型的原始计数（如果调用的 time_duration 是 special_value，则结果将不可预测）。   
time_duration td(0,0,0, 1000);
td.ticks() // --> 1000
   
time_duration time_duration::unit()
 返回时间间隔类型的最小可能单位（1 纳秒）。   
time_duration::unit() --> time_duration(0,0,0,1)
   
bool is_neg_infinity() const
 如果 time_duration 是负无穷大，则返回 true。   
time_duration td(neg_infin);
td.is_neg_infinity(); // --> true
   
bool is_pos_infinity() const
 如果 time_duration 是正无穷大，则返回 true。   
time_duration td(pos_infin); 
td.is_pos_infinity(); // --> true
   
bool is_not_a_date_time() const
 如果值不是时间，则返回 true。   
time_duration td(not_a_date_time);
td.is_not_a_date_time(); // --> true
   
bool is_special() const
 如果 time_duration 是任何 special_value，则返回 true。   
time_duration td(pos_infin); 
time_duration td2(not_a_date_time); 
time_duration td3(2,5,10);
td.is_special(); // --> true
td2.is_special(); // --> true
td3.is_special(); // --> false
  

转换为字符串

语法 描述
示例
 
std::string to_simple_string(time_duration)
 转换为 HH:MM:SS.fffffffff 格式，其中 fffffffff 是小数秒，只有在非零时才包含。 
10:00:01.123456789
std::string to_iso_string(time_duration)
 转换为 HHMMSS.fffffffff 格式，其中小数秒只有在非零时才包含。 
100001.123456789

运算符

语法 描述
示例
 
operator<<, operator>>
 流运算符。注意：自 1.33 版本以来，流操作得到了极大的改进。有关更多详细信息（包括异常和错误条件），请参阅 Date Time IO System。 
time_duration td(0,0,0);
stringstream ss("14:23:11.345678");
ss >> td; 
std::cout << td; // "14:23:11.345678"
  
operator==, operator!=,
operator>, operator<,
operator>=, operator<=
 完整的比较运算符集。 
dd1 == dd2, etc
time_duration operator+(time_duration)
 相加时间间隔。 
time_duration td1(hours(1)+minutes(2));
time_duration td2(seconds(10));
time_duration td3 = td1 + td2;
time_duration operator-(time_duration)
 减去时间间隔。 
time_duration td1(hours(1)+nanoseconds(2));
time_duration td2 = td1 - minutes(1);
time_duration operator/(int)
 将时间间隔的长度除以整数值。丢弃任何余数。 
hours(3)/2 == time_duration(1,30,0);
nanosecond(3)/2 == nanosecond(1);
time_duration operator*(int)
 将时间间隔的长度乘以整数值。 
hours(3)*2 == hours(6);

struct tm, time_t, and FILETIME 函数

提供了将 time_duration 转换为 tm 结构的函数。

语法 描述
示例
 
tm to_tm(time_duration)
 一个将 time_duration 对象转换为 tm 结构的函数。tm_year、tm_mon、tm_mday、tm_wday、tm_yday 字段设置为零。tm_isdst 字段设置为 -1。 
time_duration td(1,2,3);
tm td_tm = to_tm(td);
/* tm_year => 0
   tm_mon  => 0
   tm_mday => 0
   tm_wday => 0
   tm_yday => 0
   tm_hour => 1
   tm_min  => 2
   tm_sec  => 3
   tm_isdst => -1 */

时间周期

引言 -- 头文件 -- 构造 -- 修改器 -- 访问器 -- 转换为字符串 -- 运算符

引言

boost::posix_time::time_period 类直接表示两个时间之间的范围。周期通过简化程序的条件逻辑来简化某些类型的计算。

以开始和结束点相等或持续时间为零创建的周期称为零长度周期。零长度周期被视为无效（构造一个无效周期是完全合法的）。对于这些周期，最后一个点将始终比开始点小一个单位。

时间周期示例提供了使用时间周期的示例。

头文件

#include "boost/date_time/posix_time/posix_time.hpp" //include all types plus i/o
or
#include "boost/date_time/posix_time/posix_time_types.hpp" //no i/o just types

构造

语法 描述
示例
 
time_period(ptime,
            ptime)
 创建周期为 [begin, end)。如果 end <= begin，则周期将被定义为无效。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //10 sec after midnight
ptime t2(d, hours(10)); //10 hours after midnight
time_period tp(t1, t2);
time_period(ptime, 
            time_duration)
 创建周期为 [begin, begin+len)，其中 end 为 begin+len。如果 len <= zero，则周期将被定义为无效。 
date d(2002,Jan,01);
ptime t(d, seconds(10)); //10 sec after midnight
time_period tp(t, hours(3));
time_period(time_period rhs)
 复制构造函数 
time_period tp1(tp);

修改器

语法 描述
示例
 
time_period shift(time_duration)
 向 begin 和 end 添加持续时间。 
time_period tp(ptime(date(2005,Jan,1),hours(1)), hours(2));
tp.shift(minutes(5)); 
// tp == 2005-Jan-01 01:05:00 to 2005-Jan-01 03:05:00
             
time_period expand(days)
 从开始点减去时间间隔，并向结束点添加时间间隔。 
time_period tp(ptime(date(2005,Jan,1),hours(1)), hours(2));
tp.expand(minutes(5)); 
// tp == 2005-Jan-01 00:55:00 to 2005-Jan-01 03:05:00

访问器

语法 描述
示例
 
ptime begin()
 返回周期的第一个时间。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //10 sec after midnight
ptime t2(d, hours(10)); //10 hours after midnight
time_period tp(t1, t2);
tp.begin(); // --> 2002-Jan-01 00:00:10
ptime last()
 返回周期中的最后一个时间。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //10 sec after midnight
ptime t2(d, hours(10)); //10 hours after midnight
time_period tp(t1, t2);
tp.last();// --> 2002-Jan-01 09:59:59.999999999
ptime end()
 返回周期最后一个点之后的一个点。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //10 sec after midnight
ptime t2(d, hours(10)); //10 hours after midnight
time_period tp(t1, t2);
tp.end(); // --> 2002-Jan-01 10:00:00
time_duration length()
 返回时间周期的长度。 
date d(2002,Jan,01);
ptime t1(d); //midnight
time_period tp(t1, hours(1));
tp.length() --> 1 hour
bool is_null()
 如果周期不正确，则返回 true。例如：end 小于或等于 begin。 
date d(2002,Jan,01);
ptime t1(d, hours(12)); // noon on Jan 1st
ptime t2(d, hours(9)); // 9am on Jan 1st
time_period tp(t1, t2);
tp.is_null(); // true
bool contains(ptime)
 如果 ptime 在周期内，则返回 true。零长度周期不能包含任何点。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //10 sec after midnight
ptime t2(d, hours(10)); //10 hours after midnight
ptime t3(d, hours(2)); //2 hours after midnight
time_period tp(t1, t2); 
tp.contains(t3); // true
time_period tp2(t1, t1);
tp2.contains(t1); // false
bool contains(time_period)
 如果周期在周期内，则返回 true。 
time_period tp1(ptime(d,hours(1)), 
                ptime(d,hours(12)));
time_period tp2(ptime(d,hours(2)), 
                ptime(d,hours(4)));
tp1.contains(tp2); // --> true
tp2.contains(tp1); // --> false
bool intersects(time_period)
 如果周期重叠，则返回 true。 
time_period tp1(ptime(d,hours(1)),
                ptime(d,hours(12)));
time_period tp2(ptime(d,hours(2)), 
                ptime(d,hours(4)));
tp2.intersects(tp1); // --> true
time_period intersection(time_period)
 计算两个周期的交集。如果没有交集，则为 Null。
 
time_period merge(time_period)
 返回两个周期的并集。如果没有交集，则为 Null。
 
time_period span(time_period)
 合并两个周期以及它们之间的任何间隙，使得 begin = min(p1.begin, p2.begin) 且 end = max(p1.end, p2.end)。
 

转换为字符串

语法 描述
示例
 
std::string 
  to_simple_string(time_period dp)
 转换为 [YYYY-mmm-DD hh:mm:ss.fffffffff/YYYY-mmm-DD hh:mm:ss.fffffffff] 字符串，其中 mmm 是 3 个字符的月份名称，只有在非零时才包含小数秒。 
[2002-Jan-01 01:25:10.000000001/
                2002-Jan-31 01:25:10.123456789]
// string occupies one line

运算符

语法 描述
示例
 
operator<<
 输出时间间隔的流运算符。使用 facet 输出 [date time_of_day/date time_of_day]。默认格式为 [YYYY-mmm-DD hh:mm:ss.fffffffff/YYYY-mmm-DD hh:mm:ss.fffffffff] 字符串，其中 mmm 是 3 个字符的月份名称，只有在非零时才包含小数秒。 
[2002-Jan-01 01:25:10.000000001/ \
    2002-Jan-31 01:25:10.123456789]
operator>>
 输入时间间隔的流运算符。使用 facet 读取 [date time_of_day/date time_of_day]。默认格式为 [YYYY-mmm-DD hh:mm:ss.fffffffff/YYYY-mmm-DD hh:mm:ss.fffffffff] 字符串，其中 mmm 是 3 个字符的月份名称，只有在非零时才包含小数秒。 
[2002-Jan-01 01:25:10.000000001/ \
    2002-Jan-31 01:25:10.123456789]
operator==, operator!=
 相等运算符。当 p1.begin == p2.begin && p1.last == p2.last 时，周期相等。 
if (tp1 == tp2) {...
operator<
 无重叠的排序。当 tp1.end() 小于 tp2.begin() 时，返回 true。 
if (tp1 < tp2) {...
operator>
 无重叠的排序。当 tp1.begin() 大于 tp2.end() 时，返回 true。 
if (tp1 > tp2) {... etc
operator<=, operator>=
 根据其他运算符定义。
 

时间迭代器

引言 -- 头文件 -- 概述 -- 运算符

引言

时间迭代器提供了一种遍历时间的机制。时间迭代器类似于 Bidirectional Iterators。然而，time_iterators 与标准迭代器不同，因为没有底层序列，只有一个计算函数。此外，time_iterators 可以直接与 class ptime 的实例进行比较。因此，不需要用于迭代结束点的第二个迭代器，而是可以直接使用一个时间点。例如，下面的代码使用 15 分钟的迭代间隔进行迭代。打印小时示例也说明了 time_iterator 的用法。

      
	#include "boost/date_time/posix_time/posix_time.hpp"
	#include <iostream>


	int
	main()
	{
	  using namespace boost::gregorian;
	  using namespace boost::posix_time;
	  date d(2000,Jan,20);
	  ptime start(d);
	  ptime end = start + hours(1);
	  time_iterator titr(start,minutes(15)); //increment by 15 minutes
	  //produces 00:00:00, 00:15:00, 00:30:00, 00:45:00
	  while (titr < end) {
	    std::cout << to_simple_string(*titr) << std::endl;
	    ++titr;
	  }
	  std::cout << "Now backward" << std::endl;
	  //produces 01:00:00, 00:45:00, 00:30:00, 00:15:00
	  while (titr > start) {
	    std::cout << to_simple_string(*titr) << std::endl;
	    --titr;
	  }
	}

头文件

#include "boost/date_time/posix_time/posix_time.hpp" //include all types plus i/o
or
#include "boost/date_time/posix_time/posix_time_types.hpp" //no i/o just types

概述

类别 描述
构造参数
 
time_iterator
 按指定的时间间隔递增迭代。 
ptime start_time, time_duration increment

运算符

语法 描述
示例
 
operator==(const ptime& rhs),
operator!=(const ptime& rhs),
operator>, operator<,
operator>=, operator<=
 完整的比较运算符集。 
date d(2002,Jan,1);
ptime start_time(d, hours(1));
//increment by 10 minutes
time_iterator titr(start_time, minutes(10));
ptime end_time = start_time + hours(2);
if (titr == end_time) // false
if (titr != end_time) // true
if (titr >= end_time) // false
if (titr <= end_time) // true
prefix increment
 按指定的时间间隔增加迭代器。 
//increment by 10 milli seconds
time_iterator titr(start_time, milliseconds(10));
++titr; // == start_time + 10 milliseconds
prefix decrement
 按指定的时间间隔减少迭代器。 
time_duration td(1,2,3);
time_iterator titr(start_time, td);
--titr; // == start_time - 01:02:03

Copyright © 2001-2005 CrystalClear Software, Inc

受 Boost Software License, Version 1.0 的约束。（请参阅随附文件 LICENSE_1_0.txt 或复制自 https://boost.ac.cn/LICENSE_1_0.txt）

PrevUpHomeNext