blocks|key|2278959|text|std::round函数返回一个浮点值，“将大小写舍入为零”。与任何double到int隐式转换一样，编译器将发出警告：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2278960|从“double”到“int”的转换，可能会丢失数据|blockquote|2278961|如果要返回整数值，请使用性病:一轮或std:lrint。|2278962|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/numeric/math/round|1|http://en.cppreference.com/w/cpp/numeric/math/rint^0|0|A|Y|6|15|3|0|0|C|5|0|I|9|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|12|8|@]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|K|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

The <code>std::round</code> function returns a floating point value, "rounding halfway cases away from zero". As with any <code>double</code> to <code>int</code> implicit conversion the compiler will issue a warning:

<blockquote>
 conversion from 'double' to 'int', possible loss of data
</blockquote>

Use <a href="http://en.cppreference.com/w/cpp/numeric/math/round" rel="noreferrer">std::lround</a> or <a href="http://en.cppreference.com/w/cpp/numeric/math/rint" rel="noreferrer">std::lrint</a> if you want to return an integral value.

blocks|key|326310|text|是。只要您不溢出接收类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326311|这里您不需要担心：std::round(0.9)会转到精确的1.0，因此i+==+1+得到了的保证。|offset|length|style|CODE|BOLD|326312|标准坚持最接近的积分值，可由一个double返回。|326313|注意，尽管对于IEEE754+double，2的52次方以上的所有值都是积分值！其必然结果是，您的舍入候选数已经是一个整数值，因此函数简化为无操作。因此，例如，std::round(4503599627370496.5)将返回4503599627370496的事实，首先与4503599627370496.5不能表示为double这一事实有关。|326314|作为最后的技术要点，请注意std::round表现得非常好，部分原因是任何形式的a.5+(它是四舍五入中的切入点)都是二进有理的，因此可以精确地用二进制浮点表示。这就是为什么另一种方法，例如添加0.5和截断，可以引入bug，因为如果这样做，就可以引入笑话数字。|326315|entityMap^0|0|9|F|U|3|10|6|17|3|0|G|6|0|F|6|28|U|35|G|3S|I|4F|6|0|D|A|14|3|2P|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|K|3|L|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|P|$]]

Yes. So long as you don't overflow the receiving type.
You have no concerns here: <code>std::round(0.9)</code> will round to exactly <code>1.0</code> and so <code>i == 1</code> is guaranteed
The standard insists on the closest integral value assumable by a <code>double</code> being returned.
Note though that for an IEEE754 <code>double</code>, all values over the 52nd power of 2 are integral values! A corollary of that is that your candidate number for rounding is already an integral value, so the function reduces to a no-op. So the fact, for example, that <code>std::round(4503599627370496.5)</code> will return <code>4503599627370496</code> is all to do with the fact that <code>4503599627370496.5</code> cannot be represented as a <code>double</code> in the first place.
As final technical point, note that <code>std::round</code> is remarkably well-behaved, due in part to the fact that any number of the form <code>a.5</code> (which is the cutover point in rounding) is a dyadic rational and so can be represented exactly in binary floating point. This is why an alternative approach, such as adding <code>0.5</code> and truncating, can introduce bugs since joke digits can be introduced if you do that.

blocks|key|2279006|text|为此，C%2B%2B标准遵从C标准。在N1570+(~C11)中，round的描述如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2279007|round函数以浮点格式将其参数舍入到最近的整数值，将大小写与零相舍五入，而不考虑当前的舍入方向。|blockquote|2279008|然而，正如Ron所指出的，像lrint这样的函数完全可以做您想做的事情。|2279009|entityMap^0|T|5|0|0|5|0|E|5|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|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|L|$]]

The C++ Standard defers to the C Standard for this. In N1570 (~C11), the description of <code>round</code> is as follows:

<blockquote>
 The <code>round</code> functions round their argument to the nearest integer value in floating-point format, rounding halfway cases away from zero, regardless of the current rounding direction.
</blockquote>

However, as Ron pointed out, functions such as <code>lrint</code> do exactly what you want.

blocks|key|327039|text|根据优先选择|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|327040|浮点积分变换|style|BOLD|327041|浮点类型的prvalue可以转换为任意整数类型的prvalue+.小数部分被截断，即小数部分被丢弃。如果值不能适应目标类型，则行为是未定义的(即使目标类型是无符号的，模块化算法也不适用)。如果目标类型是bool，则这是一个布尔转换(参见下面)。|blockquote|327042|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/language/implicit_conversion^0|2|4|0|0|0|6|0|0|1Y|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@$A|X|B|Y|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|Z|8|@$A|10|B|11|F|G]]|9|@]|C|$]]|$1|K|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

According to <a href="http://en.cppreference.com/w/cpp/language/implicit_conversion" rel="nofollow noreferrer">cppreference</a>:

Floating–integral conversions

<blockquote>
 A prvalue of floating-point type can be converted to a prvalue of any
 integer type. The fractional part is truncated, that is, the
 fractional part is discarded. If the value cannot fit into the
 destination type, the behavior is undefined (even when the destination
 type is unsigned, modulo arithmetic does not apply). If the
 destination type is bool, this is a boolean conversion (see below).
</blockquote>

blocks|key|643835|text|虽然这并不能证明在所有平台上都是正确的，但是您可以尝试舍入所有可能的浮点值，看看会发生什么：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|643836|#include+<cmath>
#include+<iostream>
#include+<limits>

int+main()+{
++//+Define+the+range+of+valid+'int'+values
++const+float+mi+=+std::numeric_limits<int>::min();
++const+float+ma+=+std::numeric_limits<int>::max();

++float+maxd+=+-std::numeric_limits<float>::infinity();
++std::size_t+k+=+0;
++//+Iterate+over+all+float+point+values+between+'mi'+and+'ma'
++for+(float+f+=+mi;+f+<+ma;+f+=+std::nextafter(f,+ma),+%2B%2Bk)+{
++++//+Static+cast+after+round
++++auto+i+=+static_cast<int>(std::round(f));
++++//+Convert+back+to+float+and+check+the+difference
++++float+d+=+std::abs(static_cast<float>(i)+-+f);
++++//+Store+the+largest+recorded+difference
++++if+(d+>+maxd)+{
++++++maxd+=+d;
++++}
++++//+Print+progress+to+the+console,+just+to+see+it's+not+stuck
++++if+(k+%25+1321+==+0)+{
++++++std::cout+<<+k+<<+":+"+<<+f+<<+"+++++++++++++++\r";
++++}
++}
++std::cout+<<+std::endl;

++//+Prints+0.5+for+me
++std::cout+<<+maxd+<<+std::endl;
}|code-block|syntax|javascript|643837|如果你担心的事情发生了，上面的程序会打印一个大于0.5的值。|643838|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Although this isn't a proof that it will be true on all platforms, you can just try to round all possible floating point values and see what happens:
<pre class="lang-cpp prettyprint-override"><code>#include &lt;cmath&gt;
#include &lt;iostream&gt;
#include &lt;limits&gt;

int main() {
 // Define the range of valid 'int' values
 const float mi = std::numeric_limits&lt;int&gt;::min();
 const float ma = std::numeric_limits&lt;int&gt;::max();

 float maxd = -std::numeric_limits&lt;float&gt;::infinity();
 std::size_t k = 0;
 // Iterate over all float point values between 'mi' and 'ma'
 for (float f = mi; f &lt; ma; f = std::nextafter(f, ma), ++k) {
 // Static cast after round
 auto i = static_cast&lt;int&gt;(std::round(f));
 // Convert back to float and check the difference
 float d = std::abs(static_cast&lt;float&gt;(i) - f);
 // Store the largest recorded difference
 if (d &gt; maxd) {
 maxd = d;
 }
 // Print progress to the console, just to see it's not stuck
 if (k % 1321 == 0) {
 std::cout &lt;&lt; k &lt;&lt; &quot;: &quot; &lt;&lt; f &lt;&lt; &quot; \r&quot;;
 }
 }
 std::cout &lt;&lt; std::endl;

 // Prints 0.5 for me
 std::cout &lt;&lt; maxd &lt;&lt; std::endl;
}

</code></pre>
If what you feared could happen did happen, the program above would print a value larger than 0.5.

blocks|key|2279095|text|在int中添加0.5然后进行浇铸(截断)如何？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2279096|if(x+<+0)+{+//number+is+negative
+return+(int)+x+-+0.5;
}+else+{
+return+(int)+x+%2B+0.5;//number+is+positive
}|code-block|syntax|javascript|2279097|在您的示例中，它肯定会返回1，因为1.49999999999强制转换为int是1。|2279098|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

how about adding 0.5 and then casting to int (truncating)

<pre><code>if(x &lt; 0) { //number is negative
 return (int) x - 0.5;
} else {
 return (int) x + 0.5;//number is positive
}
</code></pre>

in your example it should return 1 for sure 
 because 1.49999999999 cast to int is 1

I have a question about <a href="http://www.cplusplus.com/reference/cmath/round/" rel="noreferrer">std::round</a> with signature: <code>double round (double x);</code>

Let's say I have this code: 

<pre><code>int i = std::round(0.9);
</code></pre>

In this case, <code>std::round</code> should return <code>1.00000000000</code>, but that's uncomfortably close to <code>0.9999999999999</code> and I'm concerned that floating-point errors will end up rounding this down. 

I would hope that <code>i == 1</code>, but is this guaranteed?

Is it safe to cast to int from std::round?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

关于有签名的，我有一个问题：double round (double x);假设我有这样的代码：int i = std::round(0.9);在这种情况下，std::round应该返回1.00000000000，但这与0.9999999999999非常接近，我担心浮点错误最终会舍弃它。我希望i == 1，但这是保证吗？

问从std：：圆形进行int安全吗？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从std：：圆形进行int安全吗？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从std：：圆形进行int安全吗？
EN