blocks|key|1371959|text|获取开始处的系统时间(以毫秒为单位)，并在末尾再取一次，然后减去。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1371960|要在POSIX中获取自1970年以来的毫秒数，您可以这样写：|1371961|struct+timeval+tv;

gettimeofday(&tv,+NULL);
return+((((unsigned+long+long)tv.tv_sec)+*+1000)+%2B
++++++++(((unsigned+long+long)tv.tv_usec)+/+1000));|code-block|syntax|javascript|1371962|要获取从Windows上的1601开始的毫秒数，您可以这样写：|1371963|SYSTEMTIME+systime;
FILETIME+filetime;

GetSystemTime(&systime);
if+(!SystemTimeToFileTime(&systime,+&filetime))
++++return+0;

unsigned+long+long+ns_since_1601;
ULARGE_INTEGER*+ptr+=+(ULARGE_INTEGER*)&ns_since_1601;

//+copy+the+result+into+the+ULARGE_INTEGER;+this+is+actually
//+copying+the+result+into+the+ns_since_1601+unsigned+long+long.
ptr->u.LowPart+=+filetime.dwLowDateTime;
ptr->u.HighPart+=+filetime.dwHighDateTime;

//+Compute+the+number+of+milliseconds+since+1601;+we+have+to
//+divide+by+10,000,+since+the+current+value+is+the+number+of+100ns
//+intervals+since+1601,+not+ms.
return+(ns_since_1601+/+10000);|1371964|如果您希望对Windows答案进行规范化，使其也返回1970年以来的毫秒数，那么您必须将答案调整11644473600000毫秒。但是，如果您只关心经过的时间，那么就没有必要这么做。|1371965|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Get the system time in milliseconds at the beginning, and again at the end, and subtract.

To get the number of milliseconds since 1970 in POSIX you would write:

<pre><code>struct timeval tv;

gettimeofday(&amp;tv, NULL);
return ((((unsigned long long)tv.tv_sec) * 1000) +
 (((unsigned long long)tv.tv_usec) / 1000));
</code></pre>

To get the number of milliseconds since 1601 on Windows you would write:

<pre><code>SYSTEMTIME systime;
FILETIME filetime;

GetSystemTime(&amp;systime);
if (!SystemTimeToFileTime(&amp;systime, &amp;filetime))
 return 0;

unsigned long long ns_since_1601;
ULARGE_INTEGER* ptr = (ULARGE_INTEGER*)&amp;ns_since_1601;

// copy the result into the ULARGE_INTEGER; this is actually
// copying the result into the ns_since_1601 unsigned long long.
ptr-&gt;u.LowPart = filetime.dwLowDateTime;
ptr-&gt;u.HighPart = filetime.dwHighDateTime;

// Compute the number of milliseconds since 1601; we have to
// divide by 10,000, since the current value is the number of 100ns
// intervals since 1601, not ms.
return (ns_since_1601 / 10000);
</code></pre>

If you cared to normalize the Windows answer so that it also returned the number of milliseconds since 1970, then you would have to adjust your answer by 11644473600000 milliseconds. But that isn't necessary if all you care about is the elapsed time.

blocks|key|1372014|text|我会认真考虑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)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1372015|它是跨平台的，易于使用，在我的经验中，它提供了操作系统提供的最高级别的时间分辨率。可能也非常重要；它提供了一些非常好的IO操作符。|1372016|要使用它来计算程序执行的差异(到微秒；可能是过度杀伤力)，它看起来像是这个浏览器编写的，而不是测试的|1372017|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';|code-block|syntax|javascript|1372018|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time.html^0|26|1Z|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I would seriously consider the use of Boost, particularly boost::posix_time::ptime and boost::posix_time::time_duration (at <a href="http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time.html" rel="noreferrer">http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time.html</a>).

It's cross-platform, easy to use, and in my experience provides the highest level of time resolution an operating system provides. Possibly also very important; it provides some very nice IO operators.

To use it to calculate the difference in program execution (to microseconds; probably overkill), it would look something like this [browser written, not tested]:

<pre><code>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 &lt;&lt; duration &lt;&lt; '\n';
</code></pre>

blocks|key|1372061|text|如果您使用的是Unix，您可以使用time来获取执行时间：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1372062|$+g%2B%2B+myprog.cpp+-o+myprog
$+time+./myprog|code-block|syntax|javascript|1372063|entityMap^0|H|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

just in case you are on Unix, you can use <code>time</code> to get the execution time:

<pre><code>$ g++ myprog.cpp -o myprog
$ time ./myprog
</code></pre>

blocks|key|1587172|text|在Windows中:使用GetTickCount|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1587173|//GetTickCount+defintition
#include+<windows.h>
int+main()
{

++++DWORD+dw1+=+GetTickCount();

++++//Do+something+

++++DWORD+dw2+=+GetTickCount();

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

}|code-block|syntax|javascript|1587174|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms724408(VS.85).aspx^0|C|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In Windows: use <a href="http://msdn.microsoft.com/en-us/library/ms724408(VS.85).aspx" rel="noreferrer">GetTickCount</a>

<pre><code>//GetTickCount defintition
#include &lt;windows.h&gt;
int main()
{

 DWORD dw1 = GetTickCount();

 //Do something 

 DWORD dw2 = GetTickCount();

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

}
</code></pre>

blocks|key|1587215|text|这似乎在英特尔Mac+10.7上运行得很好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1587216|#include+<time.h>

time_t+start+=+time(NULL);


++++//Do+your+work


time_t+end+=+time(NULL);
std::cout<<"Execution+Time:+"<<+(double)(end-start)<<"+Seconds"<<std::endl;|code-block|syntax|javascript|1587217|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This seems to work fine for intel Mac 10.7:

<pre><code>#include &lt;time.h&gt;

time_t start = time(NULL);


 //Do your work


time_t end = time(NULL);
std::cout&lt;&lt;"Execution Time: "&lt;&lt; (double)(end-start)&lt;&lt;" Seconds"&lt;&lt;std::endl;
</code></pre>

blocks|key|1587289|text|如果您使用的是c%2B%2B11，下面是一个简单的包装器(请参阅此gist)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1587290|#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_;
};|code-block|syntax|javascript|1587291|或者对于*nix上的c%2B%2B03：|1587292|#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+%2B
++++++++++++(end_.tv_nsec+-+beg_.tv_nsec)+/+1000000000.;
++++}

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

private:
++++timespec+beg_,+end_;
};|1587293|用法示例：|1587294|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;
}|1587295|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/gongzhitaao/7062087^0|T|4|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

if you are using c++11, here is a simple wrapper (see this <a href="https://gist.github.com/gongzhitaao/7062087">gist</a>):

<pre><code>#include &lt;iostream&gt;
#include &lt;chrono&gt;

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

private:
 typedef std::chrono::high_resolution_clock clock_;
 typedef std::chrono::duration&lt;double, std::ratio&lt;1&gt; &gt; second_;
 std::chrono::time_point&lt;clock_&gt; beg_;
};
</code></pre>

Or for c++03 on *nix:

<pre><code>#include &lt;iostream&gt;
#include &lt;ctime&gt;

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

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

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

private:
 timespec beg_, end_;
};
</code></pre>

Example of usage:

<pre><code>int main()
{
 Timer tmr;
 double t = tmr.elapsed();
 std::cout &lt;&lt; t &lt;&lt; std::endl;

 tmr.reset();
 t = tmr.elapsed();
 std::cout &lt;&lt; t &lt;&lt; std::endl;
 return 0;
}
</code></pre>

blocks|key|1587342|text|如果您使用的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1587343|tstart+=+clock();

//+...do+something...

tend+=+clock();|code-block|syntax|javascript|1587344|然后，您将需要以下内容来获取以秒为单位的时间：|1587345|time+=+(tend+-+tstart)+/+(double)+CLOCKS_PER_SEC;|1587346|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you are using:

<pre><code>tstart = clock();

// ...do something...

tend = clock();
</code></pre>

Then you will need the following to get time in seconds:

<pre><code>time = (tend - tstart) / (double) CLOCKS_PER_SEC;
</code></pre>

blocks|key|1372361|text|对我来说，最简单的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1372362|#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();|code-block|syntax|javascript|1372363|使用这段代码，您不必执行经典的end+-+start。|offset|length|style|CODE|1372364|享受你最喜欢的方法。|1372365|entityMap^0|0|0|F|B|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

For me, the most easy way is:

<pre><code>#include &lt;boost/timer.hpp&gt;

boost::timer t;
double duration;

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

t.restart();
/* DO OTHER STUFF HERE... */
duration = t.elapsed();
</code></pre>

using this piece of code you don't have to do the classic <code>end - start</code>.

Enjoy your favorite approach.

What's the best way to calculate a time difference in C++? I'm timing the execution speed of a program, so I'm interested in milliseconds. Better yet, seconds.milliseconds..

The accepted answer works, but needs to include ctime or time.h as noted in the comments.

How to calculate a time difference in C++

在C++中计算时间差的最佳方法是什么？我对程序的执行速度进行计时，所以我对毫秒感兴趣。更好的是，seconds.milliseconds..接受的答案是有效的，但需要包括注释中提到的ctime或time.h。

问如何在C++中计算时间差
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中计算时间差EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中计算时间差
EN