C++使用chrono庫處理日期和時間的實現方法

// 定義於頭文件 <chrono>
template<
    class Rep,
    class Period = std::ratio<1>
> class duration;

// 1. 拷貝構造函數
duration( const duration& ) = default;
// 2. 通過指定時鐘周期的類型來構造對象
template< class Rep2 >
constexpr explicit duration( const Rep2& r );
// 3. 通過指定時鐘周期類型，和時鐘周期長度來構造對象
template< class Rep2, class Period2 >
constexpr duration( const duration<Rep2,Period2>& d );

constexpr rep count() const;

#include <chrono>
#include <iostream>
using namespace std;
int main()
{
    chrono::hours h(1);                          // 一小時
    chrono::milliseconds ms{ 3 };                // 3 毫秒
    chrono::duration<int, ratio<1000>> ks(3);    // 3000 秒
 
    // chrono::duration<int, ratio<1000>> d3(3.5);  // error
    chrono::duration<double> dd(6.6);               // 6.6 秒
 
    // 使用小數表示時鐘周期的次數
    chrono::duration<double, std::ratio<1, 30>> hz(3.5);
}

#include <chrono>
#include <iostream>
int main()
{
    std::chrono::milliseconds ms{3};         // 3 毫秒
    std::chrono::microseconds us = 2*ms;     // 6000 微秒
    // 時間間隔周期為 1/30 秒
    std::chrono::duration<double, std::ratio<1, 30>> hz(3.5);
 
    std::cout <<  "3 ms duration has " << ms.count() << " ticks\n"
              <<  "6000 us duration has " << us.count() << " ticks\n"
              <<  "3.5 hz duration has " << hz.count() << " ticks\n";       
}

#include <iostream>
#include <chrono>
using namespace std;
 
int main()
{
    chrono::minutes t1(10);
    chrono::seconds t2(60);
    chrono::seconds t3 = t1 - t2;
    cout << t3.count() << " second" << endl;
}

#include <iostream>
#include <chrono>
using namespace std;
 
int main()
{
    chrono::duration<double, ratio<9, 7>> d1(3);
    chrono::duration<double, ratio<6, 5>> d2(1);
    // d1 和 d2 統一之後的時鐘周期
    chrono::duration<double, ratio<3, 35>> d3 = d1 - d2;
}

// 定義於頭文件 <chrono>
template<
    class Clock,
    class Duration = typename Clock::duration
> class time_point;

// 1. 構造一個以新紀元(epoch，即：1970.1.1)作為值的對象，需要和時鐘類一起使用，不能單獨使用該無參構造函數
time_point();
// 2. 構造一個對象，表示一個時間點，其中d的持續時間從epoch開始，需要和時鐘類一起使用，不能單獨使用該構造函數
explicit time_point( const duration& d );
// 3. 拷貝構造函數，構造與t相同時間點的對象，使用的時候需要指定模板參數
template< class Duration2 >
time_point( const time_point<Clock,Duration2>& t );

duration time_since_epoch() const;

struct system_clock { // wraps GetSystemTimePreciseAsFileTime/GetSystemTimeAsFileTime
    using rep                       = long long;
    using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
    using duration                  = chrono::duration<rep, period>;
    using time_point                = chrono::time_point<system_clock>;
    static constexpr bool is_steady = false;
 
    _NODISCARD static time_point now() noexcept 
    { // get current time
        return time_point(duration(_Xtime_get_ticks()));
    }
 
    _NODISCARD static __time64_t to_time_t(const time_point& _Time) noexcept 
    { // convert to __time64_t
        return duration_cast<seconds>(_Time.time_since_epoch()).count();
    }
 
    _NODISCARD static time_point from_time_t(__time64_t _Tm) noexcept 
    { // convert from __time64_t
        return time_point{seconds{_Tm}};
    }
};

// 返回表示當前時間的時間點。
static std::chrono::time_point<std::chrono::system_clock> now() noexcept;
// 將 time_point 時間點類型轉換為 std::time_t 類型
static std::time_t to_time_t( const time_point& t ) noexcept;
// 將 std::time_t 類型轉換為 time_point 時間點類型
static std::chrono::system_clock::time_point from_time_t( std::time_t t ) noexcept;

#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;
int main()
{
    // 新紀元1970.1.1時間
    system_clock::time_point epoch;
 
    duration<int, ratio<60*60*24>> day(1);
    // 新紀元1970.1.1時間 + 1天
    system_clock::time_point ppt(day);
 
    using dday = duration<int, ratio<60 * 60 * 24>>;
    // 新紀元1970.1.1時間 + 10天
    time_point<system_clock, dday> t(dday(10));
 
    // 系統當前時間
    system_clock::time_point today = system_clock::now();
    
    // 轉換為time_t時間類型
    time_t tm = system_clock::to_time_t(today);
    cout << "今天的日期是:    " << ctime(&tm);
 
    time_t tm1 = system_clock::to_time_t(today+day);
    cout << "明天的日期是:    " << ctime(&tm1);
 
    time_t tm2 = system_clock::to_time_t(epoch);
    cout << "新紀元時間:      " << ctime(&tm2);
 
    time_t tm3 = system_clock::to_time_t(ppt);
    cout << "新紀元時間+1天:  " << ctime(&tm3);
 
    time_t tm4 = system_clock::to_time_t(t);
    cout << "新紀元時間+10天: " << ctime(&tm4);
}

struct steady_clock { // wraps QueryPerformanceCounter
    using rep                       = long long;
    using period                    = nano;
    using duration                  = nanoseconds;
    using time_point                = chrono::time_point<steady_clock>;
    static constexpr bool is_steady = true;
 
    // get current time
    _NODISCARD static time_point now() noexcept 
    { 
        // doesn't change after system boot
        const long long _Freq = _Query_perf_frequency(); 
        const long long _Ctr  = _Query_perf_counter();
        static_assert(period::num == 1, "This assumes period::num == 1.");
        const long long _Whole = (_Ctr / _Freq) * period::den;
        const long long _Part  = (_Ctr % _Freq) * period::den / _Freq;
        return time_point(duration(_Whole + _Part));
    }
};

static std::chrono::time_point<std::chrono::steady_clock> now() noexcept;

#include <chrono>
#include <iostream>
using namespace std;
using namespace std::chrono;
int main()
{
    // 獲取開始時間點
    steady_clock::time_point start = steady_clock::now();
    // 執行業務流程
    cout << "print 1000 stars ...." << endl;
    for (int i = 0; i < 1000; ++i)
    {
        cout << "*";
    }
    cout << endl;
    // 獲取結束時間點
    steady_clock::time_point last = steady_clock::now();
    // 計算差值
    auto dt = last - start;
    cout << "總共耗時: " << dt.count() << "納秒" << endl;
}

template <class ToDuration, class Rep, class Period>
  constexpr ToDuration duration_cast (const duration<Rep,Period>& dtn);

#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;
 
void f()
{
    cout << "print 1000 stars ...." << endl;
    for (int i = 0; i < 1000; ++i)
    {
        cout << "*";
    }
    cout << endl;
}
 
int main()
{
    auto t1 = steady_clock::now();
    f();
    auto t2 = steady_clock::now();
 
    // 整數時長：要求 duration_cast
    auto int_ms = duration_cast<chrono::milliseconds>(t2 - t1);
 
    // 小數時長：不要求 duration_cast
    duration<double, ratio<1, 1000>> fp_ms = t2 - t1;
 
    cout << "f() took " << fp_ms.count() << " ms, "
        << "or " << int_ms.count() << " whole milliseconds\n";
}

template <class ToDuration, class Clock, class Duration>
time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration> &t);

#include <chrono>
#include <iostream>
using namespace std;
 
using Clock = chrono::high_resolution_clock;
using Ms = chrono::milliseconds;
using Sec = chrono::seconds;
template<class Duration>
using TimePoint = chrono::time_point<Clock, Duration>;
 
void print_ms(const TimePoint<Ms>& time_point)
{
    std::cout << time_point.time_since_epoch().count() << " ms\n";
}
 
int main()
{
    TimePoint<Sec> time_point_sec(Sec(6));
    // 無精度損失, 可以進行隱式類型轉換
    TimePoint<Ms> time_point_ms(time_point_sec);
    print_ms(time_point_ms);    // 6000 ms
 
    time_point_ms = TimePoint<Ms>(Ms(6789));
    // error，會損失精度，不允許進行隱式的類型轉換
    TimePoint<Sec> sec(time_point_ms);
 
    // 顯示類型轉換,會損失精度。6789 truncated to 6000
    time_point_sec = std::chrono::time_point_cast<Sec>(time_point_ms);
    print_ms(time_point_sec); // 6000 ms
}