STL:chrono

简单地说，我们通过定义一种时钟，然后在程序的某一位置获取执行的时间点，根据两个时间点的差值，可以获得这两个时间点的时间间隔。

想要了解chrono，首先需要知道clock,duration,time_point的概念。

一 clock(时钟)，包括三种形式：

1. system_clock:计算机上的系统时间，可以调整的；
2. steady_clock: 不可调整的稳定的时钟；
3. high_resolution_clock：高分辨率的时钟；

操作：

clock::rep
clock::period
clock::time_point
clock::duration
clock::now()
clock::is_steady

二 duration（时间间隔）

	// 定义一个默认构造函数的时间间隔，以分钟为单位
    duration<int, ratio<60> > minutes;

在chrono源码中具有更多的型别定义：

// ratio中关于单位的变换
// 位于vs中的ratio standard header
typedef ratio<1, 1000000000000000000LL> atto;
typedef ratio<1, 1000000000000000LL> femto;
typedef ratio<1, 1000000000000LL> pico;

typedef ratio<1, 1000000000> nano;
typedef ratio<1, 1000000> micro;
typedef ratio<1, 1000> milli;
typedef ratio<1, 100> centi;
typedef ratio<1, 10> deci;
typedef ratio<10, 1> deca;
typedef ratio<100, 1> hecto;
typedef ratio<1000, 1> kilo;
typedef ratio<1000000, 1> mega;
typedef ratio<1000000000, 1> giga;

typedef ratio<1000000000000LL, 1> tera;
typedef ratio<1000000000000000LL, 1> peta;
typedef ratio<1000000000000000000LL, 1> exa;

// duration TYPEDEFS
typedef duration<long long, nano> nanoseconds;
typedef duration<long long, micro> microseconds;
typedef duration<long long, milli> milliseconds;
typedef duration<long long> seconds;
typedef duration<int, ratio<60> > minutes;
typedef duration<int, ratio<3600> > hours;

部分操作：

duration::rep  //  获得tick的类型
duration::period // 获得单位的类型  num为分子，den为分母
d.count（）   // 获得当前单位的count个tick
duration_cast<D>(d) // 显示的类型转换

三 time_point（时间点）

template<class _Clock,
	class _Duration = typename _Clock::duration>
	class time_point
	{	// represents a point in time
public:
	typedef _Clock clock;
	typedef _Duration duration;
	typedef typename _Duration::rep rep;
	typedef typename _Duration::period period;

	static_assert(_Is_duration<_Duration>::value,
		"duration must be an instance of std::duration");

	constexpr time_point()
		: _MyDur(_Duration::zero())
		{	// construct with value epoch
		}

	constexpr explicit time_point(const _Duration& _Other)
		: _MyDur(_Other)
		{	// construct from a duration
		}

	template<class _Duration2,
		class = typename enable_if<is_convertible<_Duration2,
			_Duration>::value,
			void>::type>
		constexpr time_point(const time_point<_Clock, _Duration2>& _Tp)
		: _MyDur(_Tp.time_since_epoch())
		{	// construct from another duration
		}

	constexpr _Duration time_since_epoch() const
		{	// get duration from epoch
		return (_MyDur);
		}

	time_point& operator+=(const _Duration& _Dur)
		{	// increment by duration
		_MyDur += _Dur;
		return (*this);
		}

	time_point& operator-=(const _Duration& _Dur)
		{	// decrement by duration
		_MyDur -= _Dur;
		return (*this);
		}

	static constexpr time_point (min)()
		{	// get minimum time point
		return (time_point((_Duration::min)()));
		}
	static constexpr time_point (max)()
		{	// get maximum time point
		return (time_point((_Duration::max)()));
		}

private:
	_Duration _MyDur;	// duration since the epoch
	};
}	// namespace chrono

四 使用
使用c++11的自动型别推导会大大的简化代码量，我们可以根据使用需求，对其进一步封装。

#include <chrono>
#include <iostream>
#include <ctime>

using namespace std;
int main()
{
	// 傻敲
	std::chrono::time_point<std::chrono::system_clock> start = \
				std::chrono::system_clock::now();
	
	_sleep(1000);

	std::chrono::time_point<std::chrono::system_clock> end = std::chrono::system_clock::now();

	std::chrono::duration<int, std::ratio<1>> diff = std::chrono::duration_cast<std::chrono::duration<int, std::ratio<1>> > ( end - start);

	cout << diff.count() << "s" << endl;
	

	//  利用型别推导
	auto start = std::chrono::system_clock::now();

	_sleep(1000);

	auto end = std::chrono::system_clock::now();

	auto diff = std::chrono::duration_cast<std::chrono::milliseconds> (end - start);
	cout << diff.count() << "ms" << endl;
	return  0;
	}