blocks|key|1762082|text|来自N3376：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1762083|20.11.7.1时钟系统/1：|1762084|类system_clock对象表示来自系统范围的实时时钟的挂钟时间.|blockquote|offset|length|style|CODE|1762085|20.11.7.2时钟稳定/1：|1762086|steady_clock类的对象表示时钟，其中time_point的值不会随着物理时间的推移而减少，而time_point的值相对于实时以稳定的速度前进。也就是说，钟是不可以调整的。|1762087|20.11.7.3时钟时间/1：|1762088|high_resolution_clock类的对象表示具有最短滴答周期的时钟。high_resolution_clock可以是system_clock或steady_clock的同义词。|1762089|例如，系统宽时钟可能会受到夏时制之类的影响，在这种情况下，将来某一时刻列出的实际时间实际上可能是过去的一个时间。(例如，在美国，秋天的时间向后移动一个小时，因此同一时间经历了“两次”)然而，steady_clock不允许受这些事情的影响。|1762090|在这种情况下，另一种思考“稳定”的方法是在20.11.3+time.clock.req/2表中定义的需求：|1762091|在表59中，C1和C2表示时钟类型。t1和t2是由C1::now()返回的值，其中调用返回t1发生在调用返回t2之前，而这两个调用都发生在C1::time_point::max()之前。注意:这意味着C1没有在t1和t2之间转圈。-end注释表达式：C1::is_steady
返回：const+bool
操作语义:如果true+t1+<=+t2总是真的，并且时钟滴答之间的时间是恒定的，则为false。|1762092|这就是他们之间的不同之处。|1762093|如果您想做基准测试，您最好的选择可能是std::high_resolution_clock，因为您的平台很可能对此时钟使用高分辨率计时器(例如QueryPerformanceCounter+)。但是，如果您正在进行基准测试，那么您应该考虑在基准测试中使用特定于平台的定时器，因为不同的平台处理这个问题的方式不同。例如，一些平台可能提供一些方法来确定程序所需时钟的实际数量(独立于运行在同一CPU上的其他进程)。更好的是，把你的手放在一个真正的剖析器上，然后使用它。|1762094|entityMap^0|0|0|1|C|0|0|0|C|N|A|1F|A|0|0|0|L|13|L|1R|C|24|C|0|2N|C|0|0|6|2|9|2|I|2|L|2|P|9|19|2|1I|2|1X|L|2S|2|2X|2|30|2|3H|D|3Y|A|4G|4|4L|8|5G|5|0|0|J|Q|1Z|N|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@$G|17|H|18|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|1A|8|@$G|1B|H|1C|I|J]|$G|1D|H|1E|I|J]|$G|1F|H|1G|I|J]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1I|8|@$G|1J|H|1K|I|J]|$G|1L|H|1M|I|J]|$G|1N|H|1O|I|J]|$G|1P|H|1Q|I|J]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1R|8|@$G|1S|H|1T|I|J]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1U|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1V|8|@$G|1W|H|1X|I|J]|$G|1Y|H|1Z|I|J]|$G|20|H|21|I|J]|$G|22|H|23|I|J]|$G|24|H|25|I|J]|$G|26|H|27|I|J]|$G|28|H|29|I|J]|$G|2A|H|2B|I|J]|$G|2C|H|2D|I|J]|$G|2E|H|2F|I|J]|$G|2G|H|2H|I|J]|$G|2I|H|2J|I|J]|$G|2K|H|2L|I|J]|$G|2M|H|2N|I|J]|$G|2O|H|2P|I|J]|$G|2Q|H|2R|I|J]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2S|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2T|8|@$G|2U|H|2V|I|J]|$G|2W|H|2X|I|J]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|2Y|8|@]|9|@]|A|$]]]|13|$]]

From N3376:

20.11.7.1 [time.clock.system]/1:

<blockquote>
 Objects of class <code>system_clock</code> represent wall clock time from the system-wide realtime clock.
</blockquote>

20.11.7.2 [time.clock.steady]/1:

<blockquote>
 Objects of class <code>steady_clock</code> represent clocks for which values of <code>time_point</code> never decrease as physical time advances and for which values of <code>time_point</code> advance at a steady rate relative to real time. That is, the clock may not be adjusted.
</blockquote>

20.11.7.3 [time.clock.hires]/1:

<blockquote>
 Objects of class <code>high_resolution_clock</code> represent clocks with the shortest tick period. <code>high_resolution_clock</code> may be a synonym for <code>system_clock</code> or <code>steady_clock</code>.
</blockquote>

For instance, the system wide clock might be affected by something like daylight savings time, at which point the actual time listed at some point in the future can actually be a time in the past. (E.g. in the US, in the fall time moves back one hour, so the same hour is experienced "twice") However, <code>steady_clock</code> is not allowed to be affected by such things.

Another way of thinking about "steady" in this case is in the requirements defined in the table of 20.11.3 [time.clock.req]/2:

<blockquote>
 In Table 59 <code>C1</code> and <code>C2</code> denote clock types. <code>t1</code> and <code>t2</code> are values returned by <code>C1::now()</code> where the call returning <code>t1</code> happens before the call returning <code>t2</code> and both of these calls occur before <code>C1::time_point::max()</code>. [ Note: this means <code>C1</code> did not wrap around between <code>t1</code> and <code>t2</code>. —end note ] 
 
 Expression: <code>C1::is_steady</code> 
 Returns: <code>const bool</code> 
 Operational Semantics: <code>true</code> if <code>t1 &lt;= t2</code> is always true and the time between clock ticks is constant, otherwise <code>false</code>.
</blockquote>

That's all the standard has on their differences.

If you want to do benchmarking, your best bet is probably going to be <code>std::high_resolution_clock</code>, because it is likely that your platform uses a high resolution timer (e.g. <code>QueryPerformanceCounter</code> on Windows) for this clock. However, if you're benchmarking, you should really consider using platform specific timers for your benchmark, because different platforms handle this differently. For instance, some platforms might give you some means of determining the actual number of clock ticks the program required (independent of other processes running on the same CPU). Better yet, get your hands on a real profiler and use that.

blocks|key|1110668|text|比利提供了一个很好的答案，基于国际标准化组织C%2B%2B标准，我完全同意。然而，故事的另一面是真实的生活。现在看来，在流行编译器的实现中，这些时钟实际上并没有什么区别：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1110669|gcc+4.8：|1110670|#ifdef+_GLIBCXX_USE_CLOCK_MONOTONIC
+++...
#else
++typedef+system_clock+steady_clock;
#endif
++typedef+system_clock+high_resolution_clock;|code-block|syntax|javascript|1110671|Visual+Studio+2012：|1110672|class+steady_clock+:+public+system_clock
{+++//+wraps+monotonic+clock
public:
++static+const+bool+is_monotonic+=+true;++++//+retained
++static+const+bool+is_steady+=+true;
};

typedef+system_clock+high_resolution_clock;|1110673|在gcc的情况下，您可以检查是否处理稳定的时钟，只需检查is_steady，并采取相应的行动。然而，VS2012似乎在这里欺骗了一点:-)|offset|length|style|CODE|1110674|如果您需要高精度的时钟，我建议您现在编写符合C%2B%2B11正式时钟接口的时钟，并等待实现赶上。这将比直接在代码中使用OS特定的API要好得多。对于Windows，您可以这样做：|1110675|//+Self-made+Windows+QueryPerformanceCounter+based+C%2B%2B11+API+compatible+clock
struct+qpc_clock+{
++typedef+std::chrono::nanoseconds+++++++++++++++++++++++duration;++++++//+nanoseconds+resolution
++typedef+duration::rep++++++++++++++++++++++++++++++++++rep;
++typedef+duration::period+++++++++++++++++++++++++++++++period;
++typedef+std::chrono::time_point<qpc_clock,+duration>+++time_point;
++static+bool+is_steady;++++++++++++++++++++++++++++++++++++++++++++++++//+=+true
++static+time_point+now()
++{
++++if(!is_inited)+{
++++++init();
++++++is_inited+=+true;
++++}
++++LARGE_INTEGER+counter;
++++QueryPerformanceCounter(&counter);
++++return+time_point(duration(static_cast<rep>((double)counter.QuadPart+/+frequency.QuadPart+*
++++++++++++++++++++++++++++++++++++++++++++++++period::den+/+period::num)));
++}

private:
++static+bool+is_inited;++++++++++++++++++++++++++++++++++++++++++++++++//+=+false
++static+LARGE_INTEGER+frequency;
++static+void+init()
++{
++++if(QueryPerformanceFrequency(&frequency)+==+0)
++++++throw+std::logic_error("QueryPerformanceCounter+not+supported:+"+%2B+std::to_string(GetLastError()));
++}
};|1110676|对于Linux来说，这甚至更容易。只需阅读clock_gettime的手册页并修改上面的代码即可。|1110677|entityMap^0|0|0|0|0|0|S|9|0|0|0|L|D|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@$O|16|P|17|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|19|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1A|8|@$O|1B|P|1C|Q|R]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|Z|$]]

Billy provided a great answer based on the ISO C++ standard that I fully agree with. However there is another side of the story - real life. It seems that right now there is really no difference between those clocks in implementation of popular compilers:

gcc 4.8:

<pre><code>#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
 ...
#else
 typedef system_clock steady_clock;
#endif
 typedef system_clock high_resolution_clock;
</code></pre>

Visual Studio 2012:

<pre><code>class steady_clock : public system_clock
{ // wraps monotonic clock
public:
 static const bool is_monotonic = true; // retained
 static const bool is_steady = true;
};

typedef system_clock high_resolution_clock;
</code></pre>

In case of gcc you can check if you deal with steady clock simply by checking <code>is_steady</code> and behave accordingly. However VS2012 seems to cheat a bit here :-)

If you need high precision clock I recommend for now writing your own clock that conforms to C++11 official clock interface and wait for implementations to catch up. It will be much better approach than using OS specific API directly in your code.
For Windows you can do it like that:

<pre><code>// Self-made Windows QueryPerformanceCounter based C++11 API compatible clock
struct qpc_clock {
 typedef std::chrono::nanoseconds duration; // nanoseconds resolution
 typedef duration::rep rep;
 typedef duration::period period;
 typedef std::chrono::time_point&lt;qpc_clock, duration&gt; time_point;
 static bool is_steady; // = true
 static time_point now()
 {
 if(!is_inited) {
 init();
 is_inited = true;
 }
 LARGE_INTEGER counter;
 QueryPerformanceCounter(&amp;counter);
 return time_point(duration(static_cast&lt;rep&gt;((double)counter.QuadPart / frequency.QuadPart *
 period::den / period::num)));
 }

private:
 static bool is_inited; // = false
 static LARGE_INTEGER frequency;
 static void init()
 {
 if(QueryPerformanceFrequency(&amp;frequency) == 0)
 throw std::logic_error("QueryPerformanceCounter not supported: " + std::to_string(GetLastError()));
 }
};
</code></pre>

For Linux it is even easier. Just read the man page of <code>clock_gettime</code> and modify the code above.

blocks|key|2240092|text|GCC+5.3.0实现|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2240093|C%2B%2B+stdlib在GCC内部消息来源：|2240094|high_resolution_clock是system_clock的别名|unordered-list-item|CODE|2240095|system_clock转发给下列可用的第一个：|2240096|clock_gettime(CLOCK_REALTIME,+...)|2240097|gettimeofday|2240098|time|2240099|2240100|​|2240101|steady_clock转发给下列可用的第一个：|2240102|clock_gettime(CLOCK_MONOTONIC,+...)|2240103|system_clock|2240104|2240105|2240106|然后，CLOCK_REALTIME对CLOCK_MONOTONIC的解释是：单调？|2240107|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/gcc-mirror/gcc/blob/gcc_5_3_0_release/libstdc%252B%252B-v3/include/std/chrono#L776|1|https://github.com/gcc-mirror/gcc/blob/gcc_5_3_0_release/libstdc%2B%2B-v3/src/c%2B%2B11/chrono.cc#L54|2|https://github.com/gcc-mirror/gcc/blob/gcc_5_3_0_release/libstdc%2B%2B-v3/src/c%2B%2B11/chrono.cc#L82|3|https://stackoverflow.com/questions/3523442/difference-between-clock-realtime-and-clock-monotonic^0|0|B|0|0|0|L|M|C|0|L|0|0|0|C|0|C|1|1|0|Y|1|0|C|1|0|4|1|0|0|0|C|0|C|2|1|0|Z|1|0|C|1|0|0|3|E|I|F|12|3|3|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1O|8|@$9|1P|A|1Q|B|K]|$9|1R|A|1S|B|K]]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|L|3|M|5|J|7|1W|8|@$9|1X|A|1Y|B|K]]|D|@$9|1Z|A|20|1|21]]|E|$]]|$1|N|3|O|5|J|7|22|8|@$9|23|A|24|B|K]]|D|@]|E|$]]|$1|P|3|Q|5|J|7|25|8|@$9|26|A|27|B|K]]|D|@]|E|$]]|$1|R|3|S|5|J|7|28|8|@$9|29|A|2A|B|K]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|2C|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|2D|8|@$9|2E|A|2F|B|K]]|D|@$9|2G|A|2H|1|2I]]|E|$]]|$1|Y|3|Z|5|J|7|2J|8|@$9|2K|A|2L|B|K]]|D|@]|E|$]]|$1|10|3|11|5|J|7|2M|8|@$9|2N|A|2O|B|K]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|2P|8|@]|D|@]|E|$]]|$1|13|3|V|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|2R|8|@$9|2S|A|2T|B|K]|$9|2U|A|2V|B|K]]|D|@$9|2W|A|2X|1|2Y]]|E|$]]|$1|16|3|-4|5|6|7|2Z|8|@]|D|@]|E|$]]]|17|$18|$5|19|1A|1B|E|$1C|1D]]|1E|$5|19|1A|1B|E|$1C|1F]]|1G|$5|19|1A|1B|E|$1C|1H]]|1I|$5|19|1A|1B|E|$1C|1J]]]]

GCC 5.3.0 implementation

C++ stdlib is inside GCC source:

<ul>
<li><a href="https://github.com/gcc-mirror/gcc/blob/gcc_5_3_0_release/libstdc%2B%2B-v3/include/std/chrono#L776" rel="noreferrer"><code>high_resolution_clock</code></a> is an alias for <code>system_clock</code></li>
<li><a href="https://github.com/gcc-mirror/gcc/blob/gcc_5_3_0_release/libstdc++-v3/src/c++11/chrono.cc#L54" rel="noreferrer"><code>system_clock</code></a> forwards to the first of the following that is available:

<ul>
<li><code>clock_gettime(CLOCK_REALTIME, ...)</code></li>
<li><code>gettimeofday</code></li>
<li><code>time</code></li>
</ul></li>
<li><a href="https://github.com/gcc-mirror/gcc/blob/gcc_5_3_0_release/libstdc++-v3/src/c++11/chrono.cc#L82" rel="noreferrer"><code>steady_clock</code></a> forwards to the first of the following that is available:

<ul>
<li><code>clock_gettime(CLOCK_MONOTONIC, ...)</code></li>
<li><code>system_clock</code></li>
</ul></li>
</ul>

Then <code>CLOCK_REALTIME</code> vs <code>CLOCK_MONOTONIC</code> is explained at: <a href="https://stackoverflow.com/questions/3523442/difference-between-clock-realtime-and-clock-monotonic">Difference between CLOCK_REALTIME and CLOCK_MONOTONIC?</a>

blocks|key|2240113|text|也许，最显著的区别是，std::chrono:system_clock的起点是1.1.1970，也就是所谓的UNIX时代。另一方面，对于std::chrono::steady_clock来说，通常是PC的启动时间，它最适合测量间隔时间。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2240114|entityMap^0|B|O|1W|P|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Maybe, the most significant difference is the fact that the starting point of <code>std::chrono:system_clock</code> is the 1.1.1970, so-called UNIX-epoch.
On the other side, for <code>std::chrono::steady_clock</code> typically the boot time of your PC and it's most suitable for measuring intervals.

blocks|key|1762154|text|霍华德·辛南特关于编年史的相关讨论，“chrono”的作者|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1762155|不要使用high_resolution_clock，因为它是其中之一的别名：|1762156|system_clock：就像一个普通的时钟，用它来做时间/日期相关的事情|unordered-list-item|1762157|steady_clock：就像秒表，用来计时。|1762158|entityMap|0|LINK|mutability|MUTABLE|url|https://youtu.be/P32hvk8b13M?t=2875^0|J|6|0|H|0|0|4|L|0|0|C|0|0|C|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|K|3|L|5|J|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<a href="https://youtu.be/P32hvk8b13M?t=2875" rel="noreferrer">Relevant talk about chrono by Howard Hinnant</a>, author of <code>chrono</code>:
don't use <code>high_resolution_clock</code>, as it's an alias for one of these:
<ul>
<li><code>system_clock</code>: it's like a regular clock, use it for time/date related stuff</li>
<li><code>steady_clock</code>: it's like a stopwatch, use it for timing things.</li>
</ul>

What is the difference between <code>std::system_clock</code> and <code>std::steady_clock</code>? (An example case that illustrate different results/behaviours would be great).

If my goal is to precisely measure execution time of functions (like a benchmark), what would be the best choice between <code>std::system_clock</code>, <code>std::steady_clock</code> and <code>std::high_resolution_clock</code>?

Difference between std::system_clock and std::steady_clock?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

std::system_clock和std::steady_clock有什么区别？(举例说明不同的结果/行为将是很好的)。如果我的目标是精确地测量函数的执行时间(就像基准)，那么在std::system_clock、std::steady_clock和std::high_resolution_clock之间最好的选择是...

问std::system_clock与std::steady_clock的差异？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::system_clock与std::steady_clock的差异？EN