C++ 基于<；chrono>；

我有以下计时器类来简化获取从一个历元开始经过的时间：

#include <chrono>

class Timer {
  public:
    void start(void);
    template <typename duration_type>
    const duration_type time_elapsed(void);
  private:
    std::chrono::high_resolution_clock::time_point epoch;
};

void Timer::start(void) {
  epoch = std::chrono::high_resolution_clock::now();
}

template <typename duration_type>
const duration_type Timer::time_elapsed(void) {
  return std::chrono::duration_cast<duration_type>(std::chrono::high_resolution_clock::now() - epoch);
}

int main(void) {
  Timer timer;

  timer.start();

  // pointless loop to cause a delay
  for (int x = 1; x < 1000000; ++x) {
    x * x * x;
  }

  std::chrono::nanoseconds elapsed = timer.time_elapsed<std::chrono::nanoseconds>();
  std::cout << elapsed.count() << std::endl;

  return 0;
}

#包括
班级计时器{
公众：
作废开始（作废）；
模板
const duration\u type经过的时间（void）；
私人：
标准：时钟：高分辨率时钟：时间点历元；
};
void计时器：：开始（void）{
epoch=std:：chrono:：高分辨率时钟：：现在（）；
}
模板
常量持续时间类型计时器：：经过的时间（无效）{
返回std:：chrono:：duration\u cast（std:：chrono:：high\u resolution\u clock:：now（）-epoch）；
}
内部主（空）{
定时器；
timer.start（）；
//导致延迟的无意义循环
对于（整数x=1；x<1000000；++x）{
x*x*x；
}
std:：chrono:：已用纳秒=计时器。已用时间（）；
std:：cout返回一个helper类，该类存储now-epoch（），并根据经过的时间对运算符T进行高精度强制转换。或者，使用一个看起来像经过的时间的
time\u passed\u（单位）
方法，然后使用time passed返回一个在运算符T上调用单位的结构

helper类运算符的过度加载使您无法检测被调用对象隐式想要的类型。
我在代码中修复了一些内容，并添加了正确使用
std:：chrono
。更改列表包括：

我从函数调用中删除了所有（空）< />参数，因为它不是C++路径：-）/LI>
我也删除了<代码>返回0；<代码> > <代码>主代码（）/c> > C++中不需要的，因为编译器会为您提供。
我键入了一个时钟，因为在当前的实现中可能很难找到一个高质量的时钟。请参阅我的答案。基本上现在您可能想使用自定义时钟，多亏了
typedef
，重构在未来可能会更容易
我将您的等待循环更改为C++11睡眠接口（如果需要，您可以在那里随机设置一些持续时间，也可以使用C++11:-）。在这种情况下，不需要进行这种更改，但它很好地显示了线程库中如何使用
std:：chrono
我将您的方法实现放在一个类中，以使编译器有机会内联它们。或者，您可以在类外的实现中使用
inline
关键字显式
我让你的
时间经过（）
方法
const
我从
time\u appeased（）
方法的返回值中删除了不必要的
const
，并在使用该方法时将其添加到另一方面，因为在该位置
const
就足够了
最后但并非最不重要的一点是，我修改了您的
time\u appeased（）
方法，以在
return
中返回时钟的本机分辨率。这是一个更好的解决方案，因为您从未在此处丢失数据。您可能希望在以特定单位（即美国）向用户提供数据时丢失它。您必须在那里使用
duration\u cast
告诉编译器您同意丢失一些数据，并且us分辨率对您来说已经足够了
我希望下面的代码和上面的更改会让您感兴趣

#include <chrono>
#include <thread>
#include <iostream>

using namespace std::chrono;

class Timer {
public:
  typedef high_resolution_clock Clock;
  void start()
  { epoch = Clock::now(); }
  Clock::duration time_elapsed() const
  { return Clock::now() - epoch; }
private:
  Clock::time_point epoch;
};

int main() {
  Timer timer;
  timer.start();

  // sleep some time
  std::this_thread::sleep_for(microseconds(40));

  const auto elapsed = timer.time_elapsed();
  std::cout << duration_cast<microseconds>(elapsed).count() << "us" << std::endl;
}

#包括
#包括
#包括
使用名称空间std:：chrono；
班级计时器{
公众：
typedef高分辨率时钟；
void start（）
{epoch=Clock:：now（）；}
时钟：：持续时间\u经过的时间（）常数
{返回时钟：：now（）-epoch；}
私人：
时钟：时间点历元；
};
int main（）{
定时器；
timer.start（）；
//睡一会儿
std:：this_thread:：sleep_for（微秒（40））；
const auto appeased=计时器。时间_appeased（）；
std:：cout我怎样才能将Timer:：time_appeased（）的用法简化为第二个片段呢？只需
返回持续时间（高分辨率\u clock:：now（）-epoch）；
@sehe：这条评论是为你删除的答案而写的。我没有否决它。你上次对它的编辑完全符合我的评论。
#include <chrono>
#include <thread>
#include <iostream>

using namespace std::chrono;

class Timer {
public:
  typedef high_resolution_clock Clock;
  void start()
  { epoch = Clock::now(); }
  Clock::duration time_elapsed() const
  { return Clock::now() - epoch; }
private:
  Clock::time_point epoch;
};

int main() {
  Timer timer;
  timer.start();

  // sleep some time
  std::this_thread::sleep_for(microseconds(40));

  const auto elapsed = timer.time_elapsed();
  std::cout << duration_cast<microseconds>(elapsed).count() << "us" << std::endl;
}