Boost C++ Libraries Home Libraries People FAQ More
PrevUpHomeNext

Posix 時間

Ptime
時間長度
時間段
時間迭代器

Posix 時間系統

簡介 -- 用例

簡介

定義一個無調整的、分辨率為納秒/微秒級的、具有穩定的計算特性的時間系統。如果是納秒級精度的，則每個 ptime 使用96位的底層存儲，而微秒級精度則每個 ptime 使用64位存儲(詳情請見 構建選項)。該時間系統使用格里曆來實現時間表示中的日期部分。

用例

例子 說明
時間算術 幾個很簡單的使用 ptime 和 time_durations 的計算。
打印小時 從時鐘取出時間，使用 time_iterator.
本地時間到 UTC 的轉換 示範多種不同方法來將本地時間轉換為 UTC 時間，包括夏令時規則。
時間段 一些簡單的計算時間段的交集並打印的例子。

Ptime

簡介 -- 頭文件 -- 構造 -- 從字符串構造 -- 從時鐘構造 -- 使用轉換函數進行構造 -- 訪問器 -- 轉換為字符串 -- 操作符 -- Struct tm, time_t, 和 FILETIME 函數

簡介

類 boost::posix_time::ptime 是處理時間點的主要接口。通常，ptime 類在構造後就不再改變，不過它也允許進行賦值。

類 ptime 依賴於 gregorian::date，作為時間點的日期部分的接口。

其它創建時間的方法還包括有 時間迭代器。

頭文件

#include "boost/date_time/posix_time/posix_time.hpp" //包含所有類型和 i/o
或
#include "boost/date_time/posix_time/posix_time_types.hpp" //只有類型沒有 i/o

構造

語法 說明
例子 
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;
 缺省構造函數。創建一個 ptime 對象，初始化為 not_a_date_time. 註：該構造函數可以通過下定義 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. 該行為受編譯本庫時的精度所影響(請見 構建及編譯器信息) 
std::string ts("2002-01-20 23:59:59.000");
ptime t(time_from_string(ts))
 
ptime from_iso_string(std::string)
 從不帶分隔的字符串構造。 
std::string ts("20020131T235959");
ptime t(from_iso_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
 返回 true 如果 ptime 是正的或負的無限。 
ptime pt(pos_infin); 
pt.is_infinity(); // --> true
 
bool is_neg_infinity() const
 返回 true 如果 ptime 為負無限。 
ptime pt(neg_infin);
pt.is_neg_infinity(); // --> true
 
bool is_pos_infinity() const
 返回 true 如果 ptime 為正無限。 
ptime pt(neg_infin); 
pt.is_pos_infinity(); // --> true
 
bool is_not_a_date_time() const
 返回 true 如果其值不是一個 ptime 
ptime pt(not_a_date_time);
pt.is_not_a_date_time(); // --> true
 
bool is_special() const
 返回 true 如果 ptime 為某個 special_value 
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一樣，流操作符得到了改進。詳情請見 日期時間 IO 系統 (包括異常和錯誤條件)。 
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;//結果為負

Struct tm, time_t, 和 FILETIME 函數

庫中提供了 posix_time 對象與 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 (星期六)
   tm_yday => 0
   tm_hour => 1
   tm_min  => 2
   tm_sec  => 3
   tm_isddst => -1 */
 
date date_from_tm(tm datetm)
 該函數將 tm 結構轉換為 date 對象。字段 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_isddst => -1 */
 
ptime from_time_t(std::time_t)
 從 time_t 參數創建一個 ptime. 在 time_t 中的秒值被加到時間點 1970-Jan-01 上。 
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 的分辨率可以在編譯期配置。更多信息請見 構建與編譯器信息。 

using namespace boost::posix_time;
time_duration td(1,2,3,4); //01:02:03.000000004 如果分辨率為納秒
time_duration td(1,2,3,4); //01:02:03.000004 如果分辨率為微秒

如下所示，從基類 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

注意，是否存在更高分辨率的類(如：納秒)取決於庫的安裝。更多信息請見 構建及編譯器信息。

處理此事的另一個方法是利用 time_duration 的 ticks_per_second() 方法來編寫可移植的代碼，這樣可以不管庫是如何編譯的。以下是計算分辨率無關的計數值的常用公式。 

count*(time_duration_ticks_per_second / count_ticks_per_second)

例如，假設我們想用表示十分之一秒的計數值來構造時間。即每一 tick 為0.1秒。 

int number_of_tenths = 5;
//創建一個分辨率無關的計數值 -- 除以10，因為一秒分為10份
int count = number_of_tenths*(time_duration::ticks_per_second()/10);
time_duration td(1,2,3,count); //01:02:03.5 //與分辨率設置無關

頭文件

#include "boost/date_time/posix_time/posix_time.hpp" //包含所有類型和 i/o
或
#include "boost/date_time/posix_time/posix_time_types.hpp" //只有類型沒有 i/o

構造

語法 說明
例子 
time_duration(hours,
              minutes,
              seconds,
              fractional_seconds)
 從計數值構造一個時間長度。參數 fractional_seconds 為一個單元值，它受應用編譯時所設置的分辨率影響(請見 構建與編譯器信息)。如果參數 fractional_seconds 超出編譯時精度的限制，則超出值將被"進位"至 seconds 字段。要創建與分辨率無關的計數請參見前文。 
time_duration td(1,2,3,9);
//1 小時 2 分 3 秒 9 納秒
time_duration td2(1,2,3,123456789);
time_duration td3(1,2,3,1000);
// 對於微秒分辨率(6位)
// td2 => "01:04:06.456789"
// td3 => "01:02:03.001000"
// 對於納秒分辨率(9位)
// 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. 該行為受本庫編譯時的精度影響(請見 構建及編譯器信息) 
std::string ts("23:59:59.000");
time_duration td(duration_from_string(ts));

訪問器

語法 說明
例子 
long 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
 
long 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
 
long seconds()
 取出規格化的秒數 +/-(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
 
long total_seconds()
 取出截斷分數後的總秒數(如果調用的 time_duration 為 special_value 則給出不可預知的結果)。 
time_duration td(1,2,3,10);
td.total_seconds(); 
// --> (1*3600) + (2*60) + 3 == 3723
 
long total_milliseconds()
 取出截掉剩餘的數字後的總毫秒數(如果調用的 time_duration 為 special_value 則給出不可預知的結果)。 
time_duration td(1,2,3,123456789);
td.total_milliseconds(); 
// HMS --> (1*3600) + (2*60) + 3 == 3723 秒
// 毫秒是3位數字
// (3723 * 1000) + 123 == 3723123
 
long total_microseconds()
 取出截掉剩餘的數字後的總微秒數(如果調用的 time_duration 為 special_value 則給出不可預知的結果)。 
time_duration td(1,2,3,123456789);
td.total_microseconds(); 
// HMS --> (1*3600) + (2*60) + 3 == 3723 秒
// 微秒是6位數字
// (3723 * 1000000) + 123456 == 3723123456
 
long total_nanoseconds()
 取出截掉剩餘的數字後的總納秒數(如果調用的 time_duration 為 special_value 則給出不可預知的結果)。 
time_duration td(1,2,3,123456789);
td.total_nanoseconds(); 
// HMS --> (1*3600) + (2*60) + 3 == 3723 秒
// 納秒是9位數字
// (3723 * 1000000000) + 123456789
//                              == 3723123456789
 
long fractional_seconds()
 取出秒的分數部分(如果調用的 time_duration 為 special_value 則給出不可預知的結果)。 
time_duration td(1,2,3, 1000);
td.fractional_seconds(); // --> 1000
 
bool is_negative()
 返回 True 如果時間長度為負。 
time_duration td(-1,0,0); 
td.is_negative(); // --> true
 
time_duration invert_sign()
 生成一個新的時間長度，將符號取反 
time_duration td(-1,0,0); 
td.invert_sign(); // --> 01:00:00
 
date_time::time_resolutions resolution()
 表示 time_duration 類的精度。time_resolutions 是一個可能的精度的枚舉類型，從秒到納秒。 
time_duration::resolution() --> nano
 
time_duration::num_fractional_digits()
 返回一個 unsigned short，表示時間精度的分數位數。 
unsigned short secs;
secs = time_duration::num_fractional_digits();
// 納秒為9，微秒為6，等等
 
time_duration::ticks_per_second()
 返回一秒的 ticks 數。例如，如果時間長度支持納秒，則返回結果為 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 unit()
 返回時間長度類型的最小可能單元(1納秒)。 
time_duration::unit() --> time_duration(0,0,0,1)
 
bool is_neg_infinity() const
 返回 true 如果 time_duration 為負無限。 
time_duration td(neg_infin);
td.is_neg_infinity(); // --> true
 
bool is_pos_infinity() const
 返回 true 如果 time_duration 為正無限。 
time_duration td(neg_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
 返回 true 如果 time_duration 為任意 special_value 
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 其中 fff 為秒的分數部分，僅當非零時包含。 
10:00:01.123456789
 
std::string to_iso_string(time_duration)
 轉換為 HHMMSS,fffffffff. 
100001,123456789

操作符

語法 說明
例子 
operator<<, operator>>
 流操作符。註：和版本1.33一樣，流操作符得到很大改進。相關詳情請見 日期時間 IO 系統(包括異常和錯誤條件)。 
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, 和 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_isddst => -1 */

時間段

簡介 -- 頭文件 -- 構造 -- 修改器 -- 訪問器 -- 轉換為字符串 -- 操作符

簡介

類 boost::posix_time::time_period 提供了對兩個時間點間的範圍的表示法。時間段可以通過簡化程序的條件判斷邏輯來簡化一些計算類型。

由相同的開始時間點和結束時間點所創建的時間段，稱為零長度時間段。零長度時間段被認為是無效的(構造一個無效的時間段是完全合法的)。對於這些時間段，last 點總是比 begin 小一個單元。

時間段例子 提供了對使用時間段的例子。

頭文件

#include "boost/date_time/posix_time/posix_time.hpp" //包含所有類型和 i/o
或
#include "boost/date_time/posix_time/posix_time_types.hpp" //只有類型沒有 i/o

構造

語法 說明
例子 
time_period(ptime,
            ptime)
 創建一個 [begin, end) 時間段。如果 end <= begin 則時間段定義為無效。 
date d(2002,Jan,01);
ptime t(d, seconds(10)); //午夜後10秒
time_period tp(t, hours(3));
 
time_period(ptime, 
            time_duration)
 創建一個 [begin, begin+len) 時間段，其中 end 為 begin+len. 如果 len <= zero 則時間段定義為無效。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //午夜後10秒
ptime t2(d, hours(10)); //午夜後10小時
time_period tp(t1, t2);
 
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)
 從 begin 減去一個長度同時為 end 加上一個長度。

訪問器

語法 說明
例子 
ptime begin()
 返回時間段的第一個時間點。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //午夜後10秒
ptime t2(d, hours(10)); //午夜後10小時
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秒
ptime t2(d, hours(10)); //午夜後10小時
time_period tp(t1, t2);
tp.last();// --> 2002-Jan-01 09:59:59.999999999
 
ptime end()
 返回時間段的 last 後的時間點 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //午夜後10秒
ptime t2(d, hours(10)); //午夜後10小時
time_period tp(t1, t2);
tp.last(); // --> 2002-Jan-01 10:00:00
 
time_duration length()
 返回時間段的長度。 
date d(2002,Jan,01);
ptime t1(d); //午夜
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)); // 1月1日中午
ptime t2(d, hours(9)); // 1月1日上午9點
time_period tp(t1, t2);
tp.is_null(); // true
 
bool contains(ptime)
 返回 True 如果 ptime 在時間段中。零長度時間段不包含任意時間點。 
date d(2002,Jan,01);
ptime t1(d, seconds(10)); //午夜後10秒
ptime t2(d, hours(10)); //午夜後10小時
ptime t3(d, hours(2)); //午夜後2小時
time_period tp(t1, t2); 
tp.contains(t3); // true
time_period tp2(t1, t1);
tp2.contains(t1); // false
 
bool contains(time_period)
 返回 True 如果 period 在時間段中。 
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]
// 佔用一行的字符串

操作符

語法 說明
例子 
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<
 無交叉的排序。返回 True 如果 tp1.end() 小於 tp2.begin() 
if (tp1 < tp2) {...
 
operator>
 無交叉的排序。返回 True 如果 tp1.begin() 大於 tp2.end() 
if (tp1 > tp2) {... etc
 
operator<=, operator>=
 根據其它操作符來定義。
 

時間迭代器

簡介 -- 頭文件 -- 概要 -- 操作符

簡介

時間迭代器提供了對時間進行迭代的一種機制。時間迭代器類似於 雙向迭代器。不過，time_iterators 與標準迭代器的區別在於，它不存在底層的序列，只有計算用的函數。此外，time_iterators 可以與 類 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)); //每次遞增15分鐘
	  //生成 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" //包含所有類型和 i/o
或
#include "boost/date_time/posix_time/posix_time_types.hpp" //只有類型沒有 i/o

概要

類 說明
構造參數 
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));
//遞增10分鐘
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
PrevUpHomeNext