1.2 Chrono time_point

ceph

时钟的说明：

  • system_clock：从系统获取的时钟；
  • steady_clock：不能被修改的时钟；
  • high_resolution_clock：高精度时钟，实际上是system_clock或者steady_clock的别名。

steady_clock可以获取稳定可靠的时间间隔，后一次调用now()的值和前一次的差值是不因为修改了系统时间而改变，它保证了稳定的时间间隔。

除了表示时间片段，有时候我们可能更想知道一个具体的时间点，这里就要提一下time_point，time_point表示的是：

  • 用来获取1970.1.1以来的秒数和当前的时间
  • 可以做一些时间的比较和算术运算
  • 可以和ctime库结合起来显示时间

看一下类的声明：

class system_clock
{
public:
    typedef microseconds                     duration;
    typedef duration::rep                    rep;
    typedef duration::period                 period;
    typedef chrono::time_point<system_clock> time_point;
    static const bool is_steady = false;
    static time_point now() _NOEXCEPT;
    static time_t     to_time_t  (const time_point& __t) _NOEXCEPT;
    static time_point from_time_t(time_t __t) _NOEXCEPT;
};
#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
class steady_clock
{
public:
    typedef nanoseconds                                   duration;
    typedef duration::rep                                 rep;
    typedef duration::period                              period;
    typedef chrono::time_point<steady_clock, duration>    time_point;
    static const bool is_steady = true;
    static time_point now() _NOEXCEPT;
};
typedef steady_clock high_resolution_clock;
#else
typedef system_clock high_resolution_clock;
#endif

这里本来应该是有三种clock的，也就是

  • system_clock
  • steady_clock
  • high_resolution_clock

但是从这里的定义来看，难道有的平台没有steady_clock？并且high_resolution_clock的定义是随着_LIBCPP_HAS_NO_MONOTONIC_CLOCK。这里的意思是说，

  • 如果没有单调的时钟，那么就需要自己定义一个steady_clock。
  • 如果有，就不用定义了，直接用system_clock。

获取一段代码的运行时间

// steady_clock example
#include <iostream>
#include <ctime>
#include <ratio>
#include <chrono>
int main ()
{
  using namespace std::chrono;
  steady_clock::time_point t1 = steady_clock::now();
  std::cout << "printing out 1000 stars...\n";
  for (int i=0; i<1000; ++i) std::cout << "*";
  std::cout << std::endl;
  steady_clock::time_point t2 = steady_clock::now();
  // 这里转换成为时间段，只不过是用double
  // 来表示，所以可以表示比如0.5秒，0.01秒这种case.
  duration<double> time_span = duration_cast<duration<double>>(t2 - t1);
  std::cout << "It took me " << time_span.count() << " seconds.";
  std::cout << std::endl;
  return 0;
}

system_clock

// system_clock example
#include <iostream>
#include <ctime>
#include <ratio>
#include <chrono>
int main ()
{
  using std::chrono::system_clock;
  // 这里声明一天的类型
  // 其实用std::chrono::hours day(24);
  std::chrono::duration<int, std::ratio<60*60*24> > one_day(1);
  // 取得当前的时间点
  system_clock::time_point today = system_clock::now();
  // 当前的时间点，加上一段时间
  system_clock::time_point tomorrow = today + one_day;
  std::time_t tt;
  tt = system_clock::to_time_t (today);
  // 注意ctime是把time_t转换成为字符串
  std::cout << "today is: " << ctime(&tt);
  tt = system_clock::to_time_t(tomorrow);
  std::cout << "tomorrow will be: " << ctime(&tt);
  return 0;
}

时间的加减

#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';
}

定时器

void fun() {
    cout<<"hello word"<<endl;
}
int main() {
    timer t; //开始计时
    fun()
    cout<<t.elapsed()<<endl; //打印fun函数耗时多少毫秒
}

自定义定时器

#include<chrono>
using namespace std;
using namespace std::chrono;
class Timer {
public:
    Timer() : m_begin(high_resolution_clock::now()) {}
    void reset() { m_begin = high_resolution_clock::now(); }
    //默认输出秒
　　double elapsed() const {
　　　　return duration_cast<duration<double>>(high_resolution_clock::now() - m_begin).count();
　　}
//默认输出毫秒
    //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;
};