如何计算C++中的时差

Question

计算C++时差的最佳方法是什么？我正在计算程序的执行速度,所以我对毫秒感兴趣.更好的是,秒.毫秒..

接受的答案有效,但需要包括ctime或time.h,如评论中所述.

Answer 1

看std::clock()功能.

const clock_t begin_time = clock();
// do something
std::cout << float( clock () - begin_time ) /  CLOCKS_PER_SEC;

如果你想计算自我(不是用户)的执行时间,最好在时钟滴答(而不是秒)中执行此操作.

编辑:
负责的头文件 - <ctime>或<time.h>

Answer 2

如果您使用的是c ++ 11,这里有一个简单的包装器(请参阅此要点):

#include <iostream>
#include <chrono>

class Timer
{
public:
    Timer() : beg_(clock_::now()) {}
    void reset() { beg_ = clock_::now(); }
    double elapsed() const { 
        return std::chrono::duration_cast<second_>
            (clock_::now() - beg_).count(); }

private:
    typedef std::chrono::high_resolution_clock clock_;
    typedef std::chrono::duration<double, std::ratio<1> > second_;
    std::chrono::time_point<clock_> beg_;
};

或者对于*nix上的c ++ 03:

#include <iostream>
#include <ctime>

class Timer
{
public:
    Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }

    double elapsed() {
        clock_gettime(CLOCK_REALTIME, &end_);
        return end_.tv_sec - beg_.tv_sec +
            (end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
    }

    void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }

private:
    timespec beg_, end_;
};

用法示例:

int main()
{
    Timer tmr;
    double t = tmr.elapsed();
    std::cout << t << std::endl;

    tmr.reset();
    t = tmr.elapsed();
    std::cout << t << std::endl;
    return 0;
}

Answer 3

我会认真考虑使用Boost,特别是boost :: posix_time :: ptime和boost :: posix_time :: time_duration(在http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time .html).

它是跨平台的,易于使用,根据我的经验,它提供了操作系统提供的最高级别的时间分辨率.可能也非常重要; 它提供了一些非常好的IO运算符.

要用它来计算程序执行的差异(到微秒;可能是矫枉过正),它看起来像这样[浏览器编写,未经过测试]:

ptime time_start(microsec_clock::local_time());
//... execution goes here ...
ptime time_end(microsec_clock::local_time());
time_duration duration(time_end - time_start);
cout << duration << '\n';

Answer 4

我添加了这个答案,以澄清接受的答案显示CPU时间可能不是您想要的时间.因为根据参考,有CPU时间和挂钟时间.挂钟时间是显示实际经过时间的时间,与其他任何条件(如其他进程共享的CPU)无关.例如,我使用多个处理器来完成某项任务,CPU时间高达18s,实际挂钟时间实际上需要2s.

为了得到你的实际时间,

#include <chrono>

auto t_start = std::chrono::high_resolution_clock::now();
// the work...
auto t_end = std::chrono::high_resolution_clock::now();

double elapsed_time_ms = std::chrono::duration<double, std::milli>(t_end-t_start).count();

Answer 5

提升1.46.0及以上包括Chrono库:

thread_clock类提供对真实线程挂钟的访问,即调用线程的实际CPU时钟.线程相对当前时间可以通过调用thread_clock :: now()获得

#include <boost/chrono/thread_clock.hpp>
{
...
    using namespace boost::chrono;
    thread_clock::time_point start = thread_clock::now();
    ...
    thread_clock::time_point stop = thread_clock::now();  
    std::cout << "duration: " << duration_cast<milliseconds>(stop - start).count() << " ms\n";

Answer 6

在Windows中:使用GetTickCount

//GetTickCount defintition
#include <windows.h>
int main()
{

    DWORD dw1 = GetTickCount();

    //Do something 

    DWORD dw2 = GetTickCount();

    cout<<"Time difference is "<<(dw2-dw1)<<" milliSeconds"<<endl;

}

Answer 7

您也可以使用clock_gettime.此方法可用于衡量:

1. 系统范围的实时时钟
2. 系统范围的单调时钟
3. 每进程CPU时间
4. 每个进程线程CPU时间

代码如下:

#include < time.h >
#include <iostream>
int main(){
  timespec ts_beg, ts_end;
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_beg);
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_end);
  std::cout << (ts_end.tv_sec - ts_beg.tv_sec) + (ts_end.tv_nsec - ts_beg.tv_nsec) / 1e9 << " sec";
}

`

Answer 8

如果你在Unix上,你可以time用来获得执行时间:

$ g++ myprog.cpp -o myprog
$ time ./myprog

Answer 9

对我来说，最简单的方法是：

#include <boost/timer.hpp>

boost::timer t;
double duration;

t.restart();
/* DO SOMETHING HERE... */
duration = t.elapsed();

t.restart();
/* DO OTHER STUFF HERE... */
duration = t.elapsed();

使用这段代码，您不必执行经典的end - start.

享受你最喜欢的方法。

Answer 10

请注意:如果您在Windows上运行,并且您确实需要精确度,则可以使用QueryPerformanceCounter.它给你时间(可能)纳秒.

Answer 11

如果您正在使用：

tstart = clock();

// ...do something...

tend = clock();

然后您将需要以下内容来获取以秒为单位的时间：

time = (tend - tstart) / (double) CLOCKS_PER_SEC;