blocks|key|4326823|text|它通常被实现为floor(value+%2B+0.5)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4326824|编辑:它可能不叫舍入，因为我知道至少有三种舍入算法:舍入到零，舍入到最接近的整数，和银行家的舍入。您要求四舍五入到最接近的整数。|4326825|entityMap^0|7|I|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

It's usually implemented as <code>floor(value + 0.5)</code>.

Edit: and it's probably not called round since there are at least three rounding algorithms I know of: round to zero, round to closest integer, and banker's rounding. You are asking for round to closest integer.

blocks|key|262923|text|在C%2B%2B98标准库中没有round()。不过，你也可以自己写一个。下面是round-half-up的一个实现|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|262924|double+round(double+d)
{
++return+floor(d+%2B+0.5);
}|code-block|syntax|javascript|262925|在C%2B%2B98标准库中没有round函数的可能原因是它实际上可以以不同的方式实现。上面是一种常见的方法，但也有其他方法，如round-to-even，它的偏差较小，如果您要进行大量舍入，通常会更好；尽管实现起来有点复杂。|262926|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Rounding#Round_half_up|1|http://en.wikipedia.org/wiki/Rounding#Round_half_to_even^0|10|D|0|0|0|1O|D|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

There's no round() in the C++98 standard library. You can write one yourself though. The following is an implementation of <a href="https://en.wikipedia.org/wiki/Rounding#Round_half_up" rel="noreferrer">round-half-up</a>:

<pre><code>double round(double d)
{
 return floor(d + 0.5);
}
</code></pre>

The probable reason there is no round function in the C++98 standard library is that it can in fact be implemented in different ways. The above is one common way but there are others such as <a href="http://en.wikipedia.org/wiki/Rounding#Round_half_to_even" rel="noreferrer">round-to-even</a>, which is less biased and generally better if you're going to do a lot of rounding; it's a bit more complex to implement though.

blocks|key|998470|text|我这样做了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|998471|#include+<cmath.h>

using+namespace+std;

double+roundh(double+number,+int+place){

++++/*+place+=+decimal+point.+Putting+in+0+will+make+it+round+to+whole
++++++++++++++++++++++++++++++number.+putting+in+1+will+round+to+the
++++++++++++++++++++++++++++++tenths+digit.
++++*/

++++number+*=+10%5Eplace;
++++int+istack+=+(int)floor(number);
++++int+out+=+number-istack;
++++if+(out+<+0.5){
++++++++floor(number);
++++++++number+/=+10%5Eplace;
++++++++return+number;
++++}
++++if+(out+>+0.4)+{
++++++++ceil(number);
++++++++number+/=+10%5Eplace;
++++++++return+number;
++++}
}|code-block|syntax|javascript|998472|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|$]]

I did this:

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

using namespace std;

double roundh(double number, int place){

 /* place = decimal point. Putting in 0 will make it round to whole
 number. putting in 1 will round to the
 tenths digit.
 */

 number *= 10^place;
 int istack = (int)floor(number);
 int out = number-istack;
 if (out &lt; 0.5){
 floor(number);
 number /= 10^place;
 return number;
 }
 if (out &gt; 0.4) {
 ceil(number);
 number /= 10^place;
 return number;
 }
}
</code></pre>

blocks|key|4326880|text|您可以使用以下命令将精度舍入到n位：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4326881|double+round(+double+x+)
{
const+double+sd+=+1000;+//for+accuracy+to+3+decimal+places
return+int(x*sd+%2B+(x<0?+-0.5+:+0.5))/sd;
}|code-block|syntax|javascript|4326882|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|$]]

You could round to n digits precision with:

<pre><code>double round( double x )
{
const double sd = 1000; //for accuracy to 3 decimal places
return int(x*sd + (x&lt;0? -0.5 : 0.5))/sd;
}
</code></pre>

blocks|key|3479826|text|我们正在研究两个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3479827|3479828|舍入转换|ordered-list-item|3479829|类型转换。|3479830|3479831|四舍五入转换表示将±浮动/双精度舍入到最近的楼层/天花板浮动/双精度。也许你的问题到此为止了。但是，如果您希望返回Int/Long，则需要执行类型转换，因此“溢出”问题可能会影响您的解决方案。因此，请检查函数中的错误|3479832|long+round(double+x)+{
+++assert(x+>=+LONG_MIN-0.5);
+++assert(x+<=+LONG_MAX%2B0.5);
+++if+(x+>=+0)
++++++return+(long)+(x%2B0.5);
+++return+(long)+(x-0.5);
}

#define+round(x)+((x)+<+LONG_MIN-0.5+%7C%7C+(x)+>+LONG_MAX%2B0.5+?\
++++++error()+:+((x)>=0?(long)((x)%2B0.5):(long)((x)-0.5))|code-block|syntax|javascript|3479833|来自：http://www.cs.tut.fi/~jkorpela/round.html|offset|length|3479834|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.tut.fi/~jkorpela/round.html^0|0|0|0|0|0|0|0|3|15|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|18|8|@]|9|@$R|19|S|1A|1|1B]]|A|$]]|$1|T|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

There are 2 problems we are looking at:

<ol>
<li>rounding conversions </li>
<li>type conversion.</li>
</ol>

Rounding conversions mean rounding ± float/double to nearest floor/ceil float/double.
May be your problem ends here.
But if you are expected to return Int/Long, you need to perform type conversion, and thus "Overflow" problem might hit your solution. SO, do a check for error in your function

<pre><code>long round(double x) {
 assert(x &gt;= LONG_MIN-0.5);
 assert(x &lt;= LONG_MAX+0.5);
 if (x &gt;= 0)
 return (long) (x+0.5);
 return (long) (x-0.5);
}

#define round(x) ((x) &lt; LONG_MIN-0.5 || (x) &gt; LONG_MAX+0.5 ?\
 error() : ((x)&gt;=0?(long)((x)+0.5):(long)((x)-0.5))
</code></pre>

from : <a href="http://www.cs.tut.fi/~jkorpela/round.html" rel="noreferrer">http://www.cs.tut.fi/~jkorpela/round.html</a>

blocks|key|3479893|text|//+Convert+the+float+to+a+string
//+We+might+use+stringstream,+but+it+looks+like+it+truncates+the+float+to+only
//5+decimal+points+(maybe+that's+what+you+want+anyway+=P)

float+MyFloat+=+5.11133333311111333;
float+NewConvertedFloat+=+0.0;
string+FirstString+=+"+";
string+SecondString+=+"+";
stringstream+ss+(stringstream::in+%7C+stringstream::out);
ss+<<+MyFloat;
FirstString+=+ss.str();

//+Take+out+how+ever+many+decimal+places+you+want
//+(this+is+a+string+it+includes+the+point)
SecondString+=+FirstString.substr(0,5);
//whatever+precision+decimal+place+you+want

//+Convert+it+back+to+a+float
stringstream(SecondString)+>>+NewConvertedFloat;
cout+<<+NewConvertedFloat;
system("pause");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3479894|这可能是一种低效、肮脏的转换方式，但见鬼，它是有效的。它很好，因为它适用于实际的浮点数。不仅在视觉上影响输出。|unstyled|3479895|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>// Convert the float to a string
// We might use stringstream, but it looks like it truncates the float to only
//5 decimal points (maybe that's what you want anyway =P)

float MyFloat = 5.11133333311111333;
float NewConvertedFloat = 0.0;
string FirstString = " ";
string SecondString = " ";
stringstream ss (stringstream::in | stringstream::out);
ss &lt;&lt; MyFloat;
FirstString = ss.str();

// Take out how ever many decimal places you want
// (this is a string it includes the point)
SecondString = FirstString.substr(0,5);
//whatever precision decimal place you want

// Convert it back to a float
stringstream(SecondString) &gt;&gt; NewConvertedFloat;
cout &lt;&lt; NewConvertedFloat;
system("pause");
</code></pre>

It might be an inefficient dirty way of conversion but heck, it works lol. And it's good, because it applies to the actual float. Not just affecting the output visually.

blocks|key|263083|text|Boost中还实现了某种类型的舍入：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|263084|#include+<iostream>

#include+<boost/numeric/conversion/converter.hpp>

template<typename+T,+typename+S>+T+round2(const+S&+x)+{
++typedef+boost::numeric::conversion_traits<T,+S>+Traits;
++typedef+boost::numeric::def_overflow_handler+OverflowHandler;
++typedef+boost::numeric::RoundEven<typename+Traits::source_type>+Rounder;
++typedef+boost::numeric::converter<T,+S,+Traits,+OverflowHandler,+Rounder>+Converter;
++return+Converter::convert(x);
}

int+main()+{
++std::cout+<<+round2<int,+double>(0.1)+<<+'+'+<<+round2<int,+double>(-0.1)+<<+'+'+<<+round2<int,+double>(-0.9)+<<+std::endl;
}|code-block|syntax|javascript|263085|请注意，只有在执行到整数的转换时，此方法才有效。|263086|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|$]]

A certain type of rounding is also implemented in Boost:

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

#include &lt;boost/numeric/conversion/converter.hpp&gt;

template&lt;typename T, typename S&gt; T round2(const S&amp; x) {
 typedef boost::numeric::conversion_traits&lt;T, S&gt; Traits;
 typedef boost::numeric::def_overflow_handler OverflowHandler;
 typedef boost::numeric::RoundEven&lt;typename Traits::source_type&gt; Rounder;
 typedef boost::numeric::converter&lt;T, S, Traits, OverflowHandler, Rounder&gt; Converter;
 return Converter::convert(x);
}

int main() {
 std::cout &lt;&lt; round2&lt;int, double&gt;(0.1) &lt;&lt; ' ' &lt;&lt; round2&lt;int, double&gt;(-0.1) &lt;&lt; ' ' &lt;&lt; round2&lt;int, double&gt;(-0.9) &lt;&lt; std::endl;
}
</code></pre>

Note that this works only if you do a to-integer conversion.

blocks|key|263119|text|值得注意的是，如果你想从四舍五入中得到一个整数结果，你不需要通过ceil或floor来传递它。也就是说，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|263120|int+round_int(+double+r+)+{
++++return+(r+>+0.0)+?+(r+%2B+0.5)+:+(r+-+0.5);+
}|code-block|syntax|javascript|263121|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|$]]

It may be worth noting that if you wanted an integer result from the rounding you don't need to pass it through either ceil or floor. I.e.,

<pre><code>int round_int( double r ) {
 return (r &gt; 0.0) ? (r + 0.5) : (r - 0.5); 
}
</code></pre>

blocks|key|3480006|text|使用modf函数的double+round(double)函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3480007|double+round(double+x)
{
++++using+namespace+std;

++++if+((numeric_limits<double>::max()+-+0.5)+<=+x)
++++++++return+numeric_limits<double>::max();

++++if+((-1*std::numeric_limits<double>::max()+%2B+0.5)+>+x)
++++++++return+(-1*std::numeric_limits<double>::max());

++++double+intpart;
++++double+fractpart+=+modf(x,+&intpart);

++++if+(fractpart+>=+0.5)
++++++++return+(intpart+%2B+1);
++++else+if+(fractpart+>=+-0.5)
++++++++return+intpart;
++++else
++++++++return+(intpart+-+1);
++++}|code-block|syntax|javascript|3480008|要使编译干净，必须包含"math.h“和"limits”。该函数根据以下四舍五入模式工作：|3480009|3480010|+5.0是5.0|unordered-list-item|3480011|+3.8轮是4.0|3480012|轮2.3是2.0|3480013|轮1.5是2.0|3480014|H112+0.501轮是1.0+H213H114+0.5轮是1.0+H215H116+0.499轮是0.0+H217H118+0.01轮是0.0<代码>H219H1200.0轮是0.0<代码>H221H1220.0|3480015|轮-0.499+is+-0.0|3480016|轮-0.501+is+-0.0|3480017|轮-0.501+is+-1.0|3480018|轮-1.5+is+-1.0|3480019|<代码>H132+-2.3轮is+-2.0H134+-3.8轮is+-4.0+-5.0+is+-5.0轮F238|3480020|entityMap^0|2|4|9|K|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|P|7|1J|8|@]|D|@]|E|$]]|$1|S|3|T|5|P|7|1K|8|@]|D|@]|E|$]]|$1|U|3|V|5|P|7|1L|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|P|7|1N|8|@]|D|@]|E|$]]|$1|10|3|11|5|P|7|1O|8|@]|D|@]|E|$]]|$1|12|3|13|5|P|7|1P|8|@]|D|@]|E|$]]|$1|14|3|15|5|P|7|1Q|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|1R|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|19|$]]

Function <code>double round(double)</code> with the use of the <code>modf</code> function:

<pre><code>double round(double x)
{
 using namespace std;

 if ((numeric_limits&lt;double&gt;::max() - 0.5) &lt;= x)
 return numeric_limits&lt;double&gt;::max();

 if ((-1*std::numeric_limits&lt;double&gt;::max() + 0.5) &gt; x)
 return (-1*std::numeric_limits&lt;double&gt;::max());

 double intpart;
 double fractpart = modf(x, &amp;intpart);

 if (fractpart &gt;= 0.5)
 return (intpart + 1);
 else if (fractpart &gt;= -0.5)
 return intpart;
 else
 return (intpart - 1);
 }
</code></pre>

To be compile clean, includes "math.h" and "limits" are necessary. The function works according to a following rounding schema:

<ul>
<li>round of 5.0 is 5.0</li>
<li>round of 3.8 is 4.0</li>
<li>round of 2.3 is 2.0</li>
<li>round of 1.5 is 2.0</li>
<li>round of 0.501 is 1.0</li>
<li>round of 0.5 is 1.0</li>
<li>round of 0.499 is 0.0</li>
<li>round of 0.01 is 0.0</li>
<li>round of 0.0 is 0.0</li>
<li>round of -0.01 is -0.0</li>
<li>round of -0.499 is -0.0</li>
<li>round of -0.5 is -0.0</li>
<li>round of -0.501 is -1.0</li>
<li>round of -1.5 is -1.0</li>
<li>round of -2.3 is -2.0</li>
<li>round of -3.8 is -4.0</li>
<li>round of -5.0 is -5.0</li>
</ul>

blocks|key|994028|text|Boost提供了一组简单的舍入函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|994029|#include+<boost/math/special_functions/round.hpp>

double+a+=+boost::math::round(1.5);+//+Yields+2.0
int+b+=+boost::math::iround(1.5);+//+Yields+2+as+an+integer|code-block|syntax|javascript|994030|有关详细信息，请参阅Boost+documentation。|offset|length|994031|编辑：从C%2B%2B11开始，就有了std::round,+std::lround,+and+std::llround。|style|BOLD|CODE|994032|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_46_1/libs/math/doc/sf_and_dist/html/math_toolkit/utils/rounding/round.html|1|http://en.cppreference.com/w/cpp/numeric/math/round^0|0|0|A|J|0|0|0|2|F|A|R|B|18|C|F|15|1|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|11|8|@]|9|@$I|12|J|13|1|14]]|A|$]]|$1|K|3|L|5|6|7|15|8|@$I|16|J|17|M|N]|$I|18|J|19|M|O]|$I|1A|J|1B|M|O]|$I|1C|J|1D|M|O]]|9|@$I|1E|J|1F|1|1G]]|A|$]]|$1|P|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]|X|$5|S|T|U|A|$V|Y]]]]

Boost offers a simple set of rounding functions.

<pre><code>#include &lt;boost/math/special_functions/round.hpp&gt;

double a = boost::math::round(1.5); // Yields 2.0
int b = boost::math::iround(1.5); // Yields 2 as an integer
</code></pre>

For more information, see the <a href="http://www.boost.org/doc/libs/1_46_1/libs/math/doc/sf_and_dist/html/math_toolkit/utils/rounding/round.html">Boost documentation</a>.

Edit: Since C++11, there are <a href="http://en.cppreference.com/w/cpp/numeric/math/round"><code>std::round</code>, <code>std::lround</code>, and <code>std::llround</code></a>.

blocks|key|3480068|text|当心floor(x%2B0.5)。以下是范围2%5E52,2%5E53中的奇数可能发生的情况|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3480069|-bash-3.2$+cat+>test-round.c+<<END

#include+<math.h>
#include+<stdio.h>

int+main()+{
++++double+x=5000000000000001.0;
++++double+y=round(x);
++++double+z=floor(x%2B0.5);
++++printf("++++++x+++++=%25f\n",x);
++++printf("round(x)++++=%25f\n",y);
++++printf("floor(x%2B0.5)=%25f\n",z);
++++return+0;
}
END

-bash-3.2$+gcc+test-round.c
-bash-3.2$+./a.out
++++++x+++++=5000000000000001.000000
round(x)++++=5000000000000001.000000
floor(x%2B0.5)=5000000000000002.000000|code-block|syntax|javascript|3480070|这是http://bugs.squeak.org/view.php?id=7134。使用像@konik这样的解决方案。|3480071|我自己的健壮版本是这样的：|3480072|double+round(double+x)
{
++++double+truncated,roundedFraction;
++++double+fraction+=+modf(x,+&truncated);
++++modf(2.0*fraction,+&roundedFraction);
++++return+truncated+%2B+roundedFraction;
}|3480073|避免使用floor(x%2B0.5)的另一个原因是使用here。|3480074|entityMap|0|LINK|mutability|MUTABLE|url|http://bugs.squeak.org/view.php?id=7134|1|https://stackoverflow.com/questions/9902968/why-does-math-round0-49999999999999994-return-1^0|2|C|0|0|2|13|0|0|0|0|P|4|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|M|3|N|5|6|7|1A|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

Beware of <code>floor(x+0.5)</code>. Here is what can happen for odd numbers in range [2^52,2^53]:

<pre><code>-bash-3.2$ cat &gt;test-round.c &lt;&lt;END

#include &lt;math.h&gt;
#include &lt;stdio.h&gt;

int main() {
 double x=5000000000000001.0;
 double y=round(x);
 double z=floor(x+0.5);
 printf(" x =%f\n",x);
 printf("round(x) =%f\n",y);
 printf("floor(x+0.5)=%f\n",z);
 return 0;
}
END

-bash-3.2$ gcc test-round.c
-bash-3.2$ ./a.out
 x =5000000000000001.000000
round(x) =5000000000000001.000000
floor(x+0.5)=5000000000000002.000000
</code></pre>

This is <a href="http://bugs.squeak.org/view.php?id=7134" rel="nofollow noreferrer">http://bugs.squeak.org/view.php?id=7134</a>. Use a solution like the one of @konik.

My own robust version would be something like:

<pre><code>double round(double x)
{
 double truncated,roundedFraction;
 double fraction = modf(x, &amp;truncated);
 modf(2.0*fraction, &amp;roundedFraction);
 return truncated + roundedFraction;
}
</code></pre>

Another reason to avoid floor(x+0.5) is given <a href="https://stackoverflow.com/questions/9902968/why-does-math-round0-49999999999999994-return-1">here</a>.

blocks|key|998658|text|根据http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf的说法，它可以从cmath中的C%2B%2B11获得。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|998659|#include+<cmath>
#include+<iostream>

int+main(int+argc,+char**+argv)+{
++std::cout+<<+"round(0.5):\t"+<<+round(0.5)+<<+std::endl;
++std::cout+<<+"round(-0.5):\t"+<<+round(-0.5)+<<+std::endl;
++std::cout+<<+"round(1.4):\t"+<<+round(1.4)+<<+std::endl;
++std::cout+<<+"round(-1.4):\t"+<<+round(-1.4)+<<+std::endl;
++std::cout+<<+"round(1.6):\t"+<<+round(1.6)+<<+std::endl;
++std::cout+<<+"round(-1.6):\t"+<<+round(-1.6)+<<+std::endl;
++return+0;
}|code-block|syntax|javascript|998660|输出：|998661|round(0.5):++1
round(-0.5):+-1
round(1.4):++1
round(-1.4):+-1
round(1.6):++2
round(-1.6):+-2|998662|entityMap|0|LINK|mutability|MUTABLE|url|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf^0|2|1T|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|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

It's available since C++11 in cmath (according to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf</a>)

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

int main(int argc, char** argv) {
 std::cout &lt;&lt; "round(0.5):\t" &lt;&lt; round(0.5) &lt;&lt; std::endl;
 std::cout &lt;&lt; "round(-0.5):\t" &lt;&lt; round(-0.5) &lt;&lt; std::endl;
 std::cout &lt;&lt; "round(1.4):\t" &lt;&lt; round(1.4) &lt;&lt; std::endl;
 std::cout &lt;&lt; "round(-1.4):\t" &lt;&lt; round(-1.4) &lt;&lt; std::endl;
 std::cout &lt;&lt; "round(1.6):\t" &lt;&lt; round(1.6) &lt;&lt; std::endl;
 std::cout &lt;&lt; "round(-1.6):\t" &lt;&lt; round(-1.6) &lt;&lt; std::endl;
 return 0;
}
</code></pre>

Output:

<pre><code>round(0.5): 1
round(-0.5): -1
round(1.4): 1
round(-1.4): -1
round(1.6): 2
round(-1.6): -2
</code></pre>

blocks|key|263340|text|如果您最终希望将round()函数的double输出转换为int，则此问题的可接受解决方案如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|263341|int+roundint(double+r)+{
++return+(int)((r+>+0.0)+?+floor(r+%2B+0.5)+:+ceil(r+-+0.5));
}|code-block|syntax|javascript|263342|在我的机器上，当传入统一的随机值时，它的时钟频率约为8.88秒。|BOLD|263343|据我所知，下面的代码在功能上是等效的，但在我的机器上以2.48秒的速度运行，从而获得了显著的性能优势：|263344|int+roundint+(double+r)+{
++int+tmp+=+static_cast<int>+(r);
++tmp+%2B=+(r-tmp>=.5)+-+(r-tmp<=-.5);
++return+tmp;
}|263345|性能更好的原因之一是跳过的分支。|263346|entityMap^0|8|7|I|6|T|3|0|0|Q|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|M]]|D|@]|E|$]]|$1|N|3|O|5|6|7|16|8|@]|D|@]|E|$]]|$1|P|3|Q|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|R|3|S|5|6|7|18|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|U|$]]

If you ultimately want to convert the <code>double</code> output of your <code>round()</code> function to an <code>int</code>, then the accepted solutions of this question will look something like:

<pre><code>int roundint(double r) {
 return (int)((r &gt; 0.0) ? floor(r + 0.5) : ceil(r - 0.5));
}
</code></pre>

This clocks in at around 8.88&nbsp;ns on my machine when passed in uniformly random values.

The below is functionally equivalent, as far as I can tell, but clocks in at 2.48&nbsp;ns on my machine, for a significant performance advantage:

<pre><code>int roundint (double r) {
 int tmp = static_cast&lt;int&gt; (r);
 tmp += (r-tmp&gt;=.5) - (r-tmp&lt;=-.5);
 return tmp;
}
</code></pre>

Among the reasons for the better performance is the skipped branching.

blocks|key|3480201|text|基于Kalaxy的响应，下面是一个模板化的解决方案，它基于自然舍入将任何浮点数舍入为最接近的整数类型。如果该值超出整数类型的范围，它还会在调试模式下抛出错误，从而大致充当一个可行的库函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3480202|++++//+round+a+floating+point+number+to+the+nearest+integer
++++template+<typename+Arg>
++++int+Round(Arg+arg)
++++{
#ifndef+NDEBUG
++++++++//+check+that+the+argument+can+be+rounded+given+the+return+type:
++++++++if+(
++++++++++++(Arg)std::numeric_limits<int>::max()+<+arg+%2B+(Arg)+0.5)+%7C%7C
++++++++++++(Arg)std::numeric_limits<int>::lowest()+>+arg+-+(Arg)+0.5)
++++++++++++)
++++++++{
++++++++++++throw+std::overflow_error("out+of+bounds");
++++++++}
#endif

++++++++return+(arg+>+(Arg)+0.0)+?+(int)(r+%2B+(Arg)+0.5)+:+(int)(r+-+(Arg)+0.5);
++++}|code-block|syntax|javascript|3480203|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|$]]

Based on Kalaxy's response, the following is a templated solution that rounds any floating point number to the nearest integer type based on natural rounding. It also throws an error in debug mode if the value is out of range of the integer type, thereby serving roughly as a viable library function.

<pre><code> // round a floating point number to the nearest integer
 template &lt;typename Arg&gt;
 int Round(Arg arg)
 {
#ifndef NDEBUG
 // check that the argument can be rounded given the return type:
 if (
 (Arg)std::numeric_limits&lt;int&gt;::max() &lt; arg + (Arg) 0.5) ||
 (Arg)std::numeric_limits&lt;int&gt;::lowest() &gt; arg - (Arg) 0.5)
 )
 {
 throw std::overflow_error("out of bounds");
 }
#endif

 return (arg &gt; (Arg) 0.0) ? (int)(r + (Arg) 0.5) : (int)(r - (Arg) 0.5);
 }
</code></pre>

blocks|key|3480223|text|我在x86架构和MS与特定C%2B%2B的asm中使用了以下循环实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3480224|__forceinline+int+Round(const+double+v)
{
++++int+r;
++++__asm
++++{
++++++++FLD+++++v
++++++++FISTP+++r
++++++++FWAIT
++++};
++++return+r;
}|code-block|syntax|javascript|3480225|更新:返回双精度值|3480226|__forceinline+double+dround(const+double+v)
{
++++double+r;
++++__asm
++++{
++++++++FLD+++++v
++++++++FRNDINT
++++++++FSTP++++r
++++++++FWAIT
++++};
++++return+r;
}|3480227|输出：|3480228|dround(0.1):+0.000000000000000
dround(-0.1):+-0.000000000000000
dround(0.9):+1.000000000000000
dround(-0.9):+-1.000000000000000
dround(1.1):+1.000000000000000
dround(-1.1):+-1.000000000000000
dround(0.49999999999999994):+0.000000000000000
dround(-0.49999999999999994):+-0.000000000000000
dround(0.5):+0.000000000000000
dround(-0.5):+-0.000000000000000|3480229|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|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I use the following implementation of round in asm for x86 architecture and MS VS specific C++:

<pre><code>__forceinline int Round(const double v)
{
 int r;
 __asm
 {
 FLD v
 FISTP r
 FWAIT
 };
 return r;
}
</code></pre>

UPD: to return double value

<pre><code>__forceinline double dround(const double v)
{
 double r;
 __asm
 {
 FLD v
 FRNDINT
 FSTP r
 FWAIT
 };
 return r;
}
</code></pre>

Output:

<pre><code>dround(0.1): 0.000000000000000
dround(-0.1): -0.000000000000000
dround(0.9): 1.000000000000000
dround(-0.9): -1.000000000000000
dround(1.1): 1.000000000000000
dround(-1.1): -1.000000000000000
dround(0.49999999999999994): 0.000000000000000
dround(-0.49999999999999994): -0.000000000000000
dround(0.5): 0.000000000000000
dround(-0.5): -0.000000000000000
</code></pre>

blocks|key|4327383|text|如果需要能够在支持C%2B%2B11标准环境中编译代码，但又需要能够在不支持该标准的环境中编译相同的代码，则可以使用函数宏为每个系统在std::round()和自定义函数之间进行选择。只需将-DCPP11或/DCPP11传递给与C%2B%2B11兼容的编译器(或使用其内置版本的宏)，并生成一个标题，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4327384|//+File:+rounding.h
#include+<cmath>

#ifdef+CPP11
++++#define+ROUND(x)+std::round(x)
#else++++/*+CPP11+*/
++++inline+double+myRound(double+x)+{
++++++++return+(x+>=+0.0+?+std::floor(x+%2B+0.5)+:+std::ceil(x+-+0.5));
++++}

++++#define+ROUND(x)+myRound(x)
#endif+++/*+CPP11+*/|code-block|syntax|javascript|4327385|有关快速示例，请参阅http://ideone.com/zal709。|4327386|这近似于不符合C%2B%2B11的环境中的std::round()，包括保留-0.0的符号位。然而，它可能会造成轻微的性能影响，并且可能会在舍入某些已知的“问题”浮点值时出现问题，例如0.49999999999999994或类似的值。|4327387|或者，如果您可以访问与C%2B%2B11兼容的编译器，则可以只从其<cmath>头中获取std::round()，并使用它来创建自己的头来定义函数(如果函数尚未定义)。但请注意，这可能不是最佳解决方案，尤其是当您需要针对多个平台进行编译时。|4327388|entityMap|0|LINK|mutability|MUTABLE|url|http://ideone.com/zal709^0|2J|7|2R|7|0|0|A|O|0|0|0|T|7|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@$9|15|A|16|1|17]]|E|$]]|$1|M|3|N|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

If you need to be able to compile code in environments that support the C++11 standard, but also need to be able to compile that same code in environments that don't support it, you could use a function macro to choose between std::round() and a custom function for each system. Just pass <code>-DCPP11</code> or <code>/DCPP11</code> to the C++11-compliant compiler (or use its built-in version macros), and make a header like this:

<pre><code>// File: rounding.h
#include &lt;cmath&gt;

#ifdef CPP11
 #define ROUND(x) std::round(x)
#else /* CPP11 */
 inline double myRound(double x) {
 return (x &gt;= 0.0 ? std::floor(x + 0.5) : std::ceil(x - 0.5));
 }

 #define ROUND(x) myRound(x)
#endif /* CPP11 */
</code></pre>

For a quick example, see <a href="http://ideone.com/zal709" rel="nofollow">http://ideone.com/zal709</a> .

This approximates std::round() in environments that aren't C++11-compliant, including preservation of the sign bit for -0.0. It may cause a slight performance hit, however, and will likely have issues with rounding certain known "problem" floating-point values such as 0.49999999999999994 or similar values.

Alternatively, if you have access to a C++11-compliant compiler, you could just grab std::round() from its <code>&lt;cmath&gt;</code> header, and use it to make your own header that defines the function if it's not already defined. Note that this may not be an optimal solution, however, especially if you need to compile for multiple platforms.

blocks|key|4327437|text|不需要实现任何东西，所以我不确定为什么有这么多答案涉及定义、函数或方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4327438|C99中的|4327439|对于类型泛型宏，我们有下面的和和头。|offset|length|style|BOLD|4327440|#include+<math.h>
double+round+(double+x);
float+roundf+(float+x);
long+double+roundl+(long+double+x);|code-block|syntax|javascript|4327441|如果你不能编译它，你可能遗漏了数学库。类似于此的命令适用于我拥有的每个C编译器(几个)。|4327442|gcc+-lm+-std=c99+...|4327443|C%2B%2B11中的|4327444|我们在#include中有以下和额外的重载，它们依赖于IEEE双精度浮点。|4327445|#include+<math.h>
double+round+(double+x);
float+round+(float+x);
long+double+round+(long+double+x);
double+round+(T+x);|4327446|也有equivalents+in+the+std+namespace。|4327447|如果您不能编译它，那么您可能正在使用C编译而不是C%2B%2B。以下基本命令对g%2B%2B+6.3.1、x86_64-w64-mingw32-g%2B%2B+6.3.0、clang-x86_64%2B%2B+3.8.0和Visual+C%2B%2B+2015社区既不产生错误，也不产生警告。|4327448|g%2B%2B+-std=c%2B%2B11+-Wall|4327449|具有序数分割的|4327450|当将两个序数相除时，其中T是短整型、整型、长整型或另一个序数，舍入表达式是这样的。|4327451|T+roundedQuotient+=+(2+*+integerNumerator+%2B+1)
++++/+(2+*+integerDenominator);|4327452|Accuracy|4327453|毫无疑问，在浮点运算中会出现看起来奇怪的不准确，但这只在数字出现时才会出现，与舍入几乎没有关系。|4327454|来源不仅仅是浮点数的IEEE表示的尾数中的有效位数，它与我们作为人类的小数思维有关。|4327455|10是5和2的乘积，5和2是相对质数。因此，IEEE浮点标准不可能完美地表示为所有二进制数字表示的十进制数。|4327456|这不是舍入算法的问题。在选择类型和设计计算、数据输入和数字显示时，应该考虑数学现实。如果应用程序显示了显示这些十进制到二进制转换问题的数字，则该应用程序在视觉上表达了数字现实中不存在的准确性，应该进行更改。|4327457|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/numeric/math/round^0|0|0|0|I|0|0|0|18|0|0|0|5|0|0|11|0|0|0|Z|2|W|0|0|0|3I|0|0|0|6|0|0|15|0|0|0|8|0|0|1C|0|0|16|0|0|1I|0|0|2V|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1U|8|@$F|1V|G|1W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1X|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1Y|8|@$F|1Z|G|20|H|I]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|21|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|22|8|@$F|23|G|24|H|I]]|9|@]|A|$]]|$1|U|3|V|5|6|7|25|8|@$F|26|G|27|H|I]]|9|@]|A|$]]|$1|W|3|X|5|L|7|28|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|29|8|@$F|2A|G|2B|H|I]]|9|@$F|2C|G|2D|1|2E]]|A|$]]|$1|10|3|11|5|6|7|2F|8|@$F|2G|G|2H|H|I]]|9|@]|A|$]]|$1|12|3|13|5|L|7|2I|8|@]|9|@]|A|$M|N]]|$1|14|3|15|5|6|7|2J|8|@$F|2K|G|2L|H|I]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2M|8|@$F|2N|G|2O|H|I]]|9|@]|A|$]]|$1|18|3|19|5|L|7|2P|8|@]|9|@]|A|$M|N]]|$1|1A|3|1B|5|6|7|2Q|8|@$F|2R|G|2S|H|I]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2T|8|@$F|2U|G|2V|H|I]]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2W|8|@$F|2X|G|2Y|H|I]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2Z|8|@$F|30|G|31|H|I]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|32|8|@$F|33|G|34|H|I]]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|35|8|@]|9|@]|A|$]]]|1L|$1M|$5|1N|1O|1P|A|$1Q|1R]]]]

There is no need to implement anything, so I'm not sure why so many answers involve defines, functions, or methods.

In C99

We have the following and and header &lt;tgmath.h&gt; for type-generic macros.

<pre><code>#include &lt;math.h&gt;
double round (double x);
float roundf (float x);
long double roundl (long double x);
</code></pre>

If you cannot compile this, you have probably left out the math library. A command similar to this works on every C compiler I have (several).

<pre><code>gcc -lm -std=c99 ...
</code></pre>

In C++11

We have the following and additional overloads in #include &lt;cmath&gt; that rely on IEEE double precision floating point.

<pre><code>#include &lt;math.h&gt;
double round (double x);
float round (float x);
long double round (long double x);
double round (T x);
</code></pre>

There are <a href="http://en.cppreference.com/w/cpp/numeric/math/round" rel="nofollow noreferrer">equivalents in the std namespace</a> too.

If you cannot compile this, you may be using C compilation instead of C++. The following basic command produces neither errors nor warnings with g++ 6.3.1, x86_64-w64-mingw32-g++ 6.3.0, clang-x86_64++ 3.8.0, and Visual C++ 2015 Community.

<pre><code>g++ -std=c++11 -Wall
</code></pre>

With Ordinal Division

When dividing two ordinal numbers, where T is short, int, long, or another ordinal, the rounding expression is this.

<pre><code>T roundedQuotient = (2 * integerNumerator + 1)
 / (2 * integerDenominator);
</code></pre>

Accuracy

There is no doubt that odd looking inaccuracies appear in floating point operations, but this is only when the numbers appear, and has little to do with rounding.

The source is not just the number of significant digits in the mantissa of the IEEE representation of a floating point number, it is related to our decimal thinking as humans.

Ten is the product of five and two, and 5 and 2 are relatively prime. Therefore the IEEE floating point standards cannot possibly be represented perfectly as decimal numbers for all binary digital representations.

This is not an issue with the rounding algorithms. It is mathematical reality that should be considered during the selection of types and the design of computations, data entry, and display of numbers. If an application displays the digits that show these decimal-binary conversion issues, then the application is visually expressing accuracy that does not exist in digital reality and should be changed.

blocks|key|4327524|text|现在，使用包含C99/C%2B%2B11数学库的C%2B%2B11编译器应该不是问题。但接下来的问题就变成了:你选择了哪个舍入函数？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4327525|C99/C%2B%2B11+round()+通常不是你想要的舍入函数。它使用一种时髦的舍入模式，在中途情况下(%2B-xxx.5000)从0取整。如果您确实特别需要舍入模式，或者您的目标是round()比rint()更快的C%2B%2B实现，那么使用它(或者使用这个问题的其他答案之一来模拟它的行为，这些答案从表面上理解它，并仔细地重现了特定的舍入行为)。|offset|length|style|BOLD|CODE|4327526|round()的四舍五入与IEEE754默认的round+to+nearest+mode+with+even+as+a+tie-break不同。Nearest-even避免了数字平均大小的统计偏差，但确实偏向偶数。|4327527|有两个数学库舍入函数使用当前的默认舍入模式：std::nearbyint()和std::rint()，这两个函数都是在C99/C%2B%2B11中添加的，因此它们随时都可以在std::round()中使用。唯一的区别是nearbyint从不引发FE_INEXACT。|4327528|出于性能原因，更喜欢+rint()+：gcc和clang都更容易内联它，但gcc从不内联nearbyint()+(即使使用-ffast-math)|4327529|4327530|适用于x86-64和AArch64的gcc/clang|4327531|I+put+some+，您可以在其中看到源代码%2B+asm输出(用于多个编译器)。有关阅读编译器输出的更多信息，请参阅this+Q&A和Matt的CppCon2017+talk：“What+Has+My+Compiler+Done+for+Me+Lately?+Unbolting+the+Compiler's+Lid”，|4327532|在FP代码中，内联小函数通常是一个很大的优势。尤其是在非Windows环境中，标准调用约定没有保留调用的寄存器，因此编译器不能跨call在XMM寄存器中保留任何fp值。因此，即使你并不真正了解asm，你仍然可以很容易地看出它是否只是一个库函数的尾部调用，或者它是否内联到一条或两条数学指令。内联到一条或两条指令的任何东西都比函数调用(对于x86或ARM上的这个特定任务)要好。|4327533|在x86上，任何内联到SSE4.1+roundsd的东西都可以使用SSE4.1+roundpd+(或AVX+vroundpd)自动矢量化。(除了需要AVX512的FP->64位整数外，FP->整数转换也以压缩SIMD形式提供。)|4327534|4327535|std::nearbyint()|unordered-list-item|4327536|4327537|-+x86+clang:+inlines+to+a+single+insn+with+`-msse4.1`.
-+x86+gcc:+inlines+to+a+single+insn+only+with+`-msse4.1+-ffast-math`,+and+only+on+gcc+5.4+and+_earlier_.++Later+gcc+never+inlines+it+(maybe+they+didn't+realize+that+one+of+the+immediate+bits+can+suppress+the+inexact+exception?++That's+what+clang+uses,+but+older+gcc+uses+the+same+immediate+as+for+`rint`+when+it+does+inline+it)
-+AArch64+gcc6.3:+inlines+to+a+single+insn+by+default.|code-block|syntax|javascript|4327538|​|4327539|4327540|std::rint|4327541|4327542|-+x86+clang:+inlines+to+a+single+insn+with+`-msse4.1`
-+x86+gcc7:+inlines+to+a+single+insn+with+`-msse4.1`.++(Without+SSE4.1,+inlines+to+several+instructions)
-+x86+gcc6.x+and+earlier:+inlines+to+a+single+insn+with+`-ffast-math+-msse4.1`.
-+AArch64+gcc:+inlines+to+a+single+insn+by+default|4327543|4327544|4327545|std::round|4327546|4327547|-+x86+clang:+doesn't+inline
-+x86+gcc:+inlines+to+multiple+instructions+with+`-ffast-math+-msse4.1`,+requiring+two+vector+constants.
-+AArch64+gcc:+inlines+to+a+single+instruction+(HW+support+for+this+rounding+mode+as+well+as+IEEE+default+and+most+others.)|4327548|4327549|4327550|std::floor+/+std::ceil+/+std::trunc|4327551|4327552|-+x86+clang:+inlines+to+a+single+insn+with+`-msse4.1`
-+x86+gcc7.x:+inlines+to+a+single+insn+with+`-msse4.1`
-+x86+gcc6.x+and+earlier:+inlines+to+a+single+insn+with+`-ffast-math+-msse4.1`
-+AArch64+gcc:+inlines+by+default+to+a+single+instruction|4327553|4327554|4327555|四舍五入为int+/+long+/+long+long|4327556|这里有两个选择:使用lrint+(类似于rint，但返回long，或者使用long+long表示llrint)，或者使用FP->FP舍入函数，然后以正常方式(带截断)转换为整数类型。有些编译器以一种方式比另一种方式优化得更好。|4327557|long+l+=+lrint(x);

int++i+=+(int)rint(x);|4327558|请注意，int+i+=+lrint(x)首先转换float或double+->+long，然后将整数截断为int。这为超出范围的整数带来了不同:在C%2B%2B中没有定义的行为，但对于x86+FP+->+int指令定义良好(编译器将发出这些指令，除非它在执行常量传播时在编译时看到UB，否则允许它生成一旦执行就会中断的代码)。|4327559|在x86上，使整数溢出的FP->整数转换会生成INT_MIN或LLONG_MIN+(+0x8000000的位模式或64位等效项，只设置了符号位)。英特尔称其为“整数不定”值。(请参阅the+cvttsd2si+manual+entry，该SSE2指令将双精度标量转换(带截断)为有符号整数。它可用于32位或64位整数目标(仅在64位模式下)。还有一个cvtsd2si+(使用当前舍入模式转换)，这是我们希望编译器发出的，但不幸的是，如果没有-ffast-math，gcc和clang就不能做到这一点。|4327560|还要注意，FP与unsigned+int+/+long之间的转换在x86上效率较低(没有AVX512)。在64位机器上转换为32位无符号是相当便宜的；只需转换为64位有符号并截断即可。但除此之外，它的速度要慢得多。|4327561|4327562|x86使用/不使用-ffast-math+-msse4.1：(int/long)rint内联到roundsd+/+cvttsd2si。(错过了对cvtsd2si的优化)。lrint根本不内联。|4327563|x86+gcc6.x和更早版本没有-ffast-math：没有-ffast-math的两种方法都不能内联|4327564|x86+gcc7：(int/long)rint分别进行循环和转换(启用SSE4.1总共2条指令，否则使用一堆内联到rint的代码，而不使用<+code+>D93)。cvtsd2si+(optimal)，不内联。不需要SSE4.1.|4327565|AArch64+gcc6.3而不使用-ffast-math：(int/long)rint内联到2条指令的所有方式内联到cvtsd2si(optimal)，的SSE4.1.|4327566|AArch64+gcc6.3+x86+-ffast-math：-ffast-math。lrint没有inline|4327567|AArch64+gcc6.3with+-ffast-math：(int/long)rint编译为对lrint的调用。lrint不内联。这可能是一个遗漏的优化，除非我们在没有-ffast-math的情况下得到的两条指令非常慢。|4327568|4327569|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Rounding#Round_half_to_even|1|http://en.cppreference.com/w/cpp/numeric/math/nearbyint|2|http://en.cppreference.com/w/cpp/numeric/math/rint|3|https://gcc.godbolt.org/#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAKxAEZSBnVAV2OUxAHIBSAJgGY8AMyxCA1AH0JyAA4AbZg3mLuABgCCfQQDtkCrGO78AwsgC2AQwIIj2NZoGY5DTPa15d%252BzIZOXrAOht%252BOw0tTG18ITcNAHoYsQsZGQticII5AE8xYGRkMXRUTAZtME4CMQBrbVQAdzEEWrEiMQ85D29rPAYxTAA3cLEawgQxIQsGAgBaPxsNAuYAIzlvRUwJbUwUhYyIeaXvAA8ASkMAdgAhMVSCVm0xDa2MjwIIY6NL7lOAEWj1OLEACoIbyobSZfLCISYVK6bwLTAEGqYAYTdAgEAPYjbZ4JCJiVHo4g4rpNBBWfEENEYzZYp7acobfrEK4WLpFMQAMWwEgAkgA5bAADXUxgB/ns/xyeQseL0MuAYgWqGslWqdQadWarXaV2e9j2yzEqwkRPpuxY%252BzExzOl2ut11Zre/A%252B31%252BBpWLhNLAi5sWhutn1tCPtxG96FeR3eZx%252BoVi8Slp1x6DEcu0CqGcjkLTBOs63T6AyG1hY5UmQmq0ysCEm0OI1Ql8dyADYkz0Um1ofdkcmxhNK9Z9RbDcxtAwLFCJEI5KgSL7LQGLvYxMursG66Np7ODoZeJdVP4AKyR51uV1x/JDj1rAjEEfIOf%252Bk6B5d29c3u8RqOfGOaDQ400EBIzwPocT6LhoK6rjc64QM8RwAZ%252BJ6hGe6jTmmDqAWhwAgVaYHnEuK6vncEBYfBwFOvhyE/jixpyAh7q4TaBEvmudx0eRx6UZo3ycEcpByFwB6cKQ2hcKowmoFwxh8Phu74iwbDeFotDCQQYm8XxFQgPw/D%252BAAnAALAeTZGacpwABy0KcqiqAeBn8VwBnCaJnDiaQkmcMJDAgKopBqa5vGkHAsAwIgKCoGYMh4MsZAUBAaCRdF0IgMApy8KQQjRQQ0LeRACzqaQCweCkGRcCppAJWYaQAPJgqVAWkFglhpssBX4KkyAEHg/TeQ1mAHJgyDMNlZXCc8TgFTeeBmKNfFtAs3mQHxqAyF1oK9ZMqJGF8wDaMwMkybQtBiJMADqFiZid1X8CdlhsEEXxkgwSKZl5CnsHQc2Cc5BUeQc5lNpMJnZLkYinP4vBiBAuCECQO78PQYjGBFUUxfDtBHKp6lHJp2m8IetBNnphOnAZqi8FZaX2QJnBOaQM0Hr5LluR5Xk%252BX52NBaFEBIAlqPQuQlB80lxApXZvmZXI2XELl%252BUNUV2glaNFURVV9K1ZkbWYM1wCtQ17WDV1PUFf1g3DRwnDleNNNuVNM2W4F82LRAy2rXg61cJMBx5JtlLbbtzB6XpJ3nZdkzXbdKTIA9T0vVmZa9lMMxvawH0Yw5nBCSJv1cP9gPA1KYgHv4BlQzDRDMsppBIyjIvw/wmMcwFOOkMCFhYKLLsZ3TDNMznnmMOz/niS3Wn8PjaW0OTqjmbPBl6U2Ta8AeGf8D9DWs03I9c/AwVhcLMWC/FtcxSgcjyvwekS1lOWUHLbkK0rDsq2YasEBr9VuU18p61/eAdUbIoJsBpDRGs/a2k0iT2xUnNPAC14CuzWqOT2W1%252BA7T2gdXcR0Q4XXjhHSs91tobDJMsMwKdFKfQzlnZmElc4AyBqXVMCpdJ6X8KoMu%252BAK7o2rsjRKaMtC8EbsPDSpAx66R0hIyRUju7CV7tnDeXA2a%252BWEXxPePNwp8IFnFA%252ByUUhmBMsAJs/Br5S1vnlAqj9iD1XKpVGqdUtY61/sJA2nVupAL6iA82ysIENTtrNficDnaIPdsgzgvt0D%252BwwbuQ6x0zq4KumvRg70ODpxptQ/u6gABKABZAuoMmz%252BF0uwkiHhmDWmhpwuGVca6aMrgIAyQjsZ8Tbh3SgX1aayJAIzeRLNFGD2UU00R2lxFSNGTpVe69ekDxUe03gkzaHTMGUyBgISQAGSAA%253D%253D%253D|4|https://stackoverflow.com/questions/38552116/how-to-remove-noise-from-gcc-clang-assembly-output|5|https://youtu.be/bSkpMdDe4g4|6|http://felixcloutier.com/x86/ROUNDPD.html|7|http://felixcloutier.com/x86/CVTTSD2SI.html^0|0|A|7|I|8|A|7|1F|A|2G|7|2O|6|0|0|7|N|1A|0|0|M|G|13|B|2B|C|2X|9|M|G|1|13|B|2|0|7|3|B|6|B|6|18|B|1P|B|0|0|0|0|B|3|1M|8|4|2G|1Z|5|0|1S|4|0|I|7|14|7|1I|8|14|7|6|0|0|0|G|0|0|0|0|0|0|9|0|0|0|0|0|0|A|0|0|0|0|0|0|A|D|9|P|A|0|0|0|0|0|5|3|B|4|I|9|0|A|5|K|4|S|4|11|9|1C|6|0|0|4|G|O|5|U|6|14|4|1H|3|0|N|7|V|9|17|9|2N|9|4V|8|64|B|2J|Q|7|0|8|8|0|0|9|K|U|E|1B|7|1L|9|20|8|2D|5|0|H|B|V|B|0|9|E|1L|4|2A|8|2A|8|2J|9|0|I|B|U|E|1N|8|1N|H|0|J|B|V|B|17|5|0|J|B|V|E|1D|5|1M|5|2E|B|0|0^^$0|@$1|2|3|4|5|6|7|37|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|38|8|@$D|39|E|3A|F|G]|$D|3B|E|3C|F|G]|$D|3D|E|3E|F|H]|$D|3F|E|3G|F|H]|$D|3H|E|3I|F|H]|$D|3J|E|3K|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|3L|8|@$D|3M|E|3N|F|H]]|9|@$D|3O|E|3P|1|3Q]]|A|$]]|$1|K|3|L|5|6|7|3R|8|@$D|3S|E|3T|F|H]|$D|3U|E|3V|F|H]|$D|3W|E|3X|F|H]|$D|3Y|E|3Z|F|H]]|9|@$D|40|E|41|1|42]|$D|43|E|44|1|45]]|A|$]]|$1|M|3|N|5|6|7|46|8|@$D|47|E|48|F|G]|$D|49|E|4A|F|G]|$D|4B|E|4C|F|H]|$D|4D|E|4E|F|H]|$D|4F|E|4G|F|H]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|4H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|4I|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|4J|8|@]|9|@$D|4K|E|4L|1|4M]|$D|4N|E|4O|1|4P]|$D|4Q|E|4R|1|4S]]|A|$]]|$1|T|3|U|5|6|7|4T|8|@$D|4U|E|4V|F|H]]|9|@]|A|$]]|$1|V|3|W|5|6|7|4W|8|@$D|4X|E|4Y|F|H]|$D|4Z|E|50|F|H]|$D|51|E|52|F|H]]|9|@$D|53|E|54|1|55]]|A|$]]|$1|X|3|-4|5|6|7|56|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|10|7|57|8|@$D|58|E|59|F|H]]|9|@]|A|$]]|$1|11|3|-4|5|6|7|5A|8|@]|9|@]|A|$]]|$1|12|3|13|5|14|7|5B|8|@]|9|@]|A|$15|16]]|$1|17|3|18|5|6|7|5C|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|5D|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|10|7|5E|8|@$D|5F|E|5G|F|H]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|5H|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|14|7|5I|8|@]|9|@]|A|$15|16]]|$1|1F|3|18|5|6|7|5J|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|5K|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|10|7|5L|8|@$D|5M|E|5N|F|H]]|9|@]|A|$]]|$1|1J|3|-4|5|6|7|5O|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|14|7|5P|8|@]|9|@]|A|$15|16]]|$1|1M|3|18|5|6|7|5Q|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|5R|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|10|7|5S|8|@$D|5T|E|5U|F|H]|$D|5V|E|5W|F|H]|$D|5X|E|5Y|F|H]]|9|@]|A|$]]|$1|1Q|3|-4|5|6|7|5Z|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|14|7|60|8|@]|9|@]|A|$15|16]]|$1|1T|3|18|5|6|7|61|8|@]|9|@]|A|$]]|$1|1U|3|-4|5|6|7|62|8|@]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|63|8|@$D|64|E|65|F|H]|$D|66|E|67|F|H]|$D|68|E|69|F|H]]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|6A|8|@$D|6B|E|6C|F|H]|$D|6D|E|6E|F|H]|$D|6F|E|6G|F|H]|$D|6H|E|6I|F|H]|$D|6J|E|6K|F|H]]|9|@]|A|$]]|$1|1Z|3|20|5|14|7|6L|8|@]|9|@]|A|$15|16]]|$1|21|3|22|5|6|7|6M|8|@$D|6N|E|6O|F|H]|$D|6P|E|6Q|F|H]|$D|6R|E|6S|F|H]|$D|6T|E|6U|F|H]|$D|6V|E|6W|F|H]]|9|@]|A|$]]|$1|23|3|24|5|6|7|6X|8|@$D|6Y|E|6Z|F|H]|$D|70|E|71|F|H]|$D|72|E|73|F|H]|$D|74|E|75|F|H]|$D|76|E|77|F|H]|$D|78|E|79|F|H]]|9|@$D|7A|E|7B|1|7C]]|A|$]]|$1|25|3|26|5|6|7|7D|8|@$D|7E|E|7F|F|H]]|9|@]|A|$]]|$1|27|3|-4|5|6|7|7G|8|@]|9|@]|A|$]]|$1|28|3|29|5|10|7|7H|8|@$D|7I|E|7J|F|H]|$D|7K|E|7L|F|H]|$D|7M|E|7N|F|H]|$D|7O|E|7P|F|H]|$D|7Q|E|7R|F|H]|$D|7S|E|7T|F|H]]|9|@]|A|$]]|$1|2A|3|2B|5|10|7|7U|8|@$D|7V|E|7W|F|H]|$D|7X|E|7Y|F|H]]|9|@]|A|$]]|$1|2C|3|2D|5|10|7|7Z|8|@$D|80|E|81|F|H]|$D|82|E|83|F|H]|$D|84|E|85|F|H]|$D|86|E|87|F|G]|$D|88|E|89|F|G]]|9|@]|A|$]]|$1|2E|3|2F|5|10|7|8A|8|@$D|8B|E|8C|F|H]|$D|8D|E|8E|F|H]|$D|8F|E|8G|F|H]|$D|8H|E|8I|F|G]]|9|@]|A|$]]|$1|2G|3|2H|5|10|7|8J|8|@$D|8K|E|8L|F|H]|$D|8M|E|8N|F|H]|$D|8O|E|8P|F|H]]|9|@]|A|$]]|$1|2I|3|2J|5|10|7|8Q|8|@$D|8R|E|8S|F|H]|$D|8T|E|8U|F|H]|$D|8V|E|8W|F|H]|$D|8X|E|8Y|F|H]|$D|8Z|E|90|F|H]]|9|@]|A|$]]|$1|2K|3|-4|5|6|7|91|8|@]|9|@]|A|$]]|$1|2L|3|-4|5|6|7|92|8|@]|9|@]|A|$]]]|2M|$2N|$5|2O|2P|2Q|A|$2R|2S]]|2T|$5|2O|2P|2Q|A|$2R|2U]]|2V|$5|2O|2P|2Q|A|$2R|2W]]|2X|$5|2O|2P|2Q|A|$2R|2Y]]|2Z|$5|2O|2P|2Q|A|$2R|30]]|31|$5|2O|2P|2Q|A|$2R|32]]|33|$5|2O|2P|2Q|A|$2R|34]]|35|$5|2O|2P|2Q|A|$2R|36]]]]

These days it shouldn't be a problem to use a C++11 compiler which includes a C99/C++11 math library. But then the question becomes: which rounding function do you pick?

C99/C++11 <code>round()</code> is often not actually the rounding function you want. It uses a funky rounding mode that rounds away from 0 as a tie-break on half-way cases (<code>+-xxx.5000</code>). If you do specifically want that rounding mode, or you're targeting a C++ implementation where <code>round()</code> is faster than <code>rint()</code>, then use it (or emulate its behaviour with one of the other answers on this question which took it at face value and carefully reproduced that specific rounding behaviour.)

<code>round()</code>'s rounding is different from the IEEE754 default <a href="https://en.wikipedia.org/wiki/Rounding#Round_half_to_even" rel="noreferrer">round to nearest mode with even as a tie-break</a>. Nearest-even avoids statistical bias in the average magnitude of numbers, but does bias towards even numbers.

There are two math library rounding functions that use the current default rounding mode: <a href="http://en.cppreference.com/w/cpp/numeric/math/nearbyint" rel="noreferrer"><code>std::nearbyint()</code></a> and <a href="http://en.cppreference.com/w/cpp/numeric/math/rint" rel="noreferrer"><code>std::rint()</code></a>, both added in C99/C++11, so they're available any time <code>std::round()</code> is. The only difference is that <code>nearbyint</code> never raises FE_INEXACT.

Prefer <code>rint()</code> for performance reasons: gcc and clang both inline it more easily, but gcc never inlines <code>nearbyint()</code> (even with <code>-ffast-math</code>)

<hr>

<h3>gcc/clang for x86-64 and AArch64</h3>

<a href="https://gcc.godbolt.org/#z:OYLghAFBqd5QCxAYwPYBMCmBRdBLAF1QCcAaPECAKxAEZSBnVAV2OUxAHIBSAJgGY8AMyxCA1AH0JyAA4AbZg3mLuABgCCfQQDtkCrGO78AwsgC2AQwIIj2NZoGY5DTPa15d%2BzIZOXrAOht%2BOw0tTG18ITcNAHoYsQsZGQticII5AE8xYGRkMXRUTAZtME4CMQBrbVQAdzEEWrEiMQ85D29rPAYxTAA3cLEawgQxIQsGAgBaPxsNAuYAIzlvRUwJbUwUhYyIeaXvAA8ASkMAdgAhMVSCVm0xDa2MjwIIY6NL7lOAEWj1OLEACoIbyobSZfLCISYVK6bwLTAEGqYAYTdAgEAPYjbZ4JCJiVHo4g4rpNBBWfEENEYzZYp7acobfrEK4WLpFMQAMWwEgAkgA5bAADXUxgB/ns/xyeQseL0MuAYgWqGslWqdQadWarXaV2e9j2yzEqwkRPpuxY%2BzExzOl2ut11Zre/A%2B31%2BBpWLhNLAi5sWhutn1tCPtxG96FeR3eZx%2BoVi8Slp1x6DEcu0CqGcjkLTBOs63T6AyG1hY5UmQmq0ysCEm0OI1Ql8dyADYkz0Um1ofdkcmxhNK9Z9RbDcxtAwLFCJEI5KgSL7LQGLvYxMursG66Np7ODoZeJdVP4AKyR51uV1x/JDj1rAjEEfIOf%2Bk6B5d29c3u8RqOfGOaDQ400EBIzwPocT6LhoK6rjc64QM8RwAZ%2BJ6hGe6jTmmDqAWhwAgVaYHnEuK6vncEBYfBwFOvhyE/jixpyAh7q4TaBEvmudx0eRx6UZo3ycEcpByFwB6cKQ2hcKowmoFwxh8Phu74iwbDeFotDCQQYm8XxFQgPw/D%2BAAnAALAeTZGacpwABy0KcqiqAeBn8VwBnCaJnDiaQkmcMJDAgKopBqa5vGkHAsAwIgKCoGYMh4MsZAUBAaCRdF0IgMApy8KQQjRQQ0LeRACzqaQCweCkGRcCppAJWYaQAPJgqVAWkFglhpssBX4KkyAEHg/TeQ1mAHJgyDMNlZXCc8TgFTeeBmKNfFtAs3mQHxqAyF1oK9ZMqJGF8wDaMwMkybQtBiJMADqFiZid1X8CdlhsEEXxkgwSKZl5CnsHQc2Cc5BUeQc5lNpMJnZLkYinP4vBiBAuCECQO78PQYjGBFUUxfDtBHKp6lHJp2m8IetBNnphOnAZqi8FZaX2QJnBOaQM0Hr5LluR5Xk%2BX52NBaFEBIAlqPQuQlB80lxApXZvmZXI2XELl%2BUNUV2glaNFURVV9K1ZkbWYM1wCtQ17WDV1PUFf1g3DRwnDleNNNuVNM2W4F82LRAy2rXg61cJMBx5JtlLbbtzB6XpJ3nZdkzXbdKTIA9T0vVmZa9lMMxvawH0Yw5nBCSJv1cP9gPA1KYgHv4BlQzDRDMsppBIyjIvw/wmMcwFOOkMCFhYKLLsZ3TDNMznnmMOz/niS3Wn8PjaW0OTqjmbPBl6U2Ta8AeGf8D9DWs03I9c/AwVhcLMWC/FtcxSgcjyvwekS1lOWUHLbkK0rDsq2YasEBr9VuU18p61/eAdUbIoJsBpDRGs/a2k0iT2xUnNPAC14CuzWqOT2W1%2BA7T2gdXcR0Q4XXjhHSs91tobDJMsMwKdFKfQzlnZmElc4AyBqXVMCpdJ6X8KoMu%2BAK7o2rsjRKaMtC8EbsPDSpAx66R0hIyRUju7CV7tnDeXA2a%2BWEXxPePNwp8IFnFA%2ByUUhmBMsAJs/Br5S1vnlAqj9iD1XKpVGqdUtY61/sJA2nVupAL6iA82ysIENTtrNficDnaIPdsgzgvt0D%2BwwbuQ6x0zq4KumvRg70ODpxptQ/u6gABKABZAuoMmz%2BF0uwkiHhmDWmhpwuGVca6aMrgIAyQjsZ8Tbh3SgX1aayJAIzeRLNFGD2UU00R2lxFSNGTpVe69ekDxUe03gkzaHTMGUyBgISQAGSAA%3D%3D%3D" rel="noreferrer">I put some test functions on Matt Godbolt's Compiler Explorer</a>, where you can see source + asm output (for multiple compilers). For more about reading compiler output, see <a href="https://stackoverflow.com/questions/38552116/how-to-remove-noise-from-gcc-clang-assembly-output">this Q&amp;A</a>, and Matt's CppCon2017 talk: <a href="https://youtu.be/bSkpMdDe4g4" rel="noreferrer">“What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid”</a>,

In FP code, it's usually a big win to inline small functions. Especially on non-Windows, where the standard calling convention has no call-preserved registers, so the compiler can't keep any FP values in XMM registers across a <code>call</code>. So even if you don't really know asm, you can still easily see whether it's just a tail-call to the library function or whether it inlined to one or two math instructions. Anything that inlines to one or two instructions is better than a function call (for this particular task on x86 or ARM).

On x86, anything that inlines to SSE4.1 <code>roundsd</code> can auto-vectorize with SSE4.1 <a href="http://felixcloutier.com/x86/ROUNDPD.html" rel="noreferrer"><code>roundpd</code></a> (or AVX <code>vroundpd</code>). (FP->integer conversions are also available in packed SIMD form, except for FP->64-bit integer which requires AVX512.)

<ul>
<li><code>std::nearbyint()</code>:

<ul>
<li>x86 clang: inlines to a single insn with <code>-msse4.1</code>.</li>
<li>x86 gcc: inlines to a single insn only with <code>-msse4.1 -ffast-math</code>, and only on gcc 5.4 and earlier. Later gcc never inlines it (maybe they didn't realize that one of the immediate bits can suppress the inexact exception? That's what clang uses, but older gcc uses the same immediate as for <code>rint</code> when it does inline it)</li>
<li>AArch64 gcc6.3: inlines to a single insn by default.</li>
</ul></li>
<li><code>std::rint</code>:

<ul>
<li>x86 clang: inlines to a single insn with <code>-msse4.1</code></li>
<li>x86 gcc7: inlines to a single insn with <code>-msse4.1</code>. (Without SSE4.1, inlines to several instructions)</li>
<li>x86 gcc6.x and earlier: inlines to a single insn with <code>-ffast-math -msse4.1</code>.</li>
<li>AArch64 gcc: inlines to a single insn by default</li>
</ul></li>
<li><code>std::round</code>:

<ul>
<li>x86 clang: doesn't inline</li>
<li>x86 gcc: inlines to multiple instructions with <code>-ffast-math -msse4.1</code>, requiring two vector constants.</li>
<li>AArch64 gcc: inlines to a single instruction (HW support for this rounding mode as well as IEEE default and most others.)</li>
</ul></li>
<li><code>std::floor</code> / <code>std::ceil</code> / <code>std::trunc</code>

<ul>
<li>x86 clang: inlines to a single insn with <code>-msse4.1</code></li>
<li>x86 gcc7.x: inlines to a single insn with <code>-msse4.1</code></li>
<li>x86 gcc6.x and earlier: inlines to a single insn with <code>-ffast-math -msse4.1</code></li>
<li>AArch64 gcc: inlines by default to a single instruction</li>
</ul></li>
</ul>

<hr>

<h1>Rounding to <code>int</code> / <code>long</code> / <code>long long</code>:</h1>

You have two options here: use <code>lrint</code> (like <code>rint</code> but returns <code>long</code>, or <code>long long</code> for <code>llrint</code>), or use an FP->FP rounding function and then convert to an integer type the normal way (with truncation). Some compilers optimize one way better than the other.

<pre><code>long l = lrint(x);

int i = (int)rint(x);
</code></pre>

Note that <code>int i = lrint(x)</code> converts <code>float</code> or <code>double</code> -> <code>long</code> first, and then truncates the integer to <code>int</code>. This makes a difference for out-of-range integers: Undefined Behaviour in C++, but well-defined for the x86 FP -> int instructions (which the compiler will emit unless it sees the UB at compile time while doing constant propagation, then it's allowed to make code that breaks if it's ever executed).

On x86, an FP->integer conversion that overflows the integer produces <code>INT_MIN</code> or <code>LLONG_MIN</code> (a bit-pattern of <code>0x8000000</code> or the 64-bit equivalent, with just the sign-bit set). Intel calls this the "integer indefinite" value. (See <a href="http://felixcloutier.com/x86/CVTTSD2SI.html" rel="noreferrer">the <code>cvttsd2si</code> manual entry</a>, the SSE2 instruction that converts (with truncation) scalar double to signed integer. It's available with 32-bit or 64-bit integer destination (in 64-bit mode only). There's also a <code>cvtsd2si</code> (convert with current rounding mode), which is what we'd like the compiler to emit, but unfortunately gcc and clang won't do that without <code>-ffast-math</code>.

Also beware that FP to/from <code>unsigned</code> int / long is less efficient on x86 (without AVX512). Conversion to 32-bit unsigned on a 64-bit machine is pretty cheap; just convert to 64-bit signed and truncate. But otherwise it's significantly slower.

<ul>
<li>x86 clang with/without <code>-ffast-math -msse4.1</code>: <code>(int/long)rint</code> inlines to <code>roundsd</code> / <code>cvttsd2si</code>. (missed optimization to <code>cvtsd2si</code>). <code>lrint</code> doesn't inline at all.</li>
<li>x86 gcc6.x and earlier without <code>-ffast-math</code>: neither way inlines</li>
<li>x86 gcc7 without <code>-ffast-math</code>: <code>(int/long)rint</code> rounds and converts separately (with 2 total instructions of SSE4.1 is enabled, otherwise with a bunch of code inlined for <code>rint</code> without <code>roundsd</code>). <code>lrint</code> doesn't inline.</li>
<li>x86 gcc with <code>-ffast-math</code>: all ways inline to <code>cvtsd2si</code> (optimal), no need for SSE4.1.</li>
<li>AArch64 gcc6.3 without <code>-ffast-math</code>: <code>(int/long)rint</code> inlines to 2 instructions. <code>lrint</code> doesn't inline</li>
<li>AArch64 gcc6.3 with <code>-ffast-math</code>: <code>(int/long)rint</code> compiles to a call to <code>lrint</code>. <code>lrint</code> doesn't inline. This may be a missed optimization unless the two instructions we get without <code>-ffast-math</code> are very slow.</li>
</ul>

blocks|key|3480434|text|将浮点值舍入"n“位小数的最佳方法是在O(1)时间内：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3480435|我们必须将值四舍五入3位，即n=3.So，|3480436|float+a=47.8732355;
printf("%25.3f",a);|code-block|syntax|javascript|3480437|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Best way to rounding off a floating value by "n" decimal places, is as following with in O(1) time:-

We have to round off the value by 3 places i.e. n=3.So,

<pre><code>float a=47.8732355;
printf("%.3f",a);
</code></pre>

blocks|key|3480456|text|从C%2B%2B+11开始，只需：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3480457|#include+<cmath>
std::round(1.1)|code-block|syntax|javascript|3480458|或者获取int|3480459|static_cast<int>(std::round(1.1))|3480460|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|$]]

Since C++ 11 simply:
<pre><code>#include &lt;cmath&gt;
std::round(1.1)
</code></pre>
or to get int
<pre><code>static_cast&lt;int&gt;(std::round(1.1))
</code></pre>

blocks|key|263740|text|带数学的ARM的round_f|type|unstyled|depth|inlineStyleRanges|entityRanges|data|263741|static+inline+float+round_f(float+value)
{
++++float+rep;
++++asm+volatile+("vrinta.f32+%250,%251"+:+"=t"(rep)+:+"t"(value));
++++return+rep;
}|code-block|syntax|javascript|263742|不带数学运算的ARM+round_f|263743|union+f__raw+{
++++struct+{
++++++++uint32_t+massa++:23;
++++++++uint32_t+order++:8;
++++++++uint32_t+sign+++:1;
++++};
++++int32_t+++++i_raw;
++++float+++++++f_raw;
};

float+round_f(float+value)
{
++++union+f__raw+raw;
++++int32_t+exx;
++++uint32_t+ex_mask;
++++raw.f_raw+=+value;
++++exx+=+raw.order+-+126;
++++if+(exx+<+0)+{
++++++++raw.i_raw+&=+0x80000000;
++++}+else+if+(exx+<+24)+{
++++++++ex_mask+=+0x00ffffff+>>+exx;
++++++++raw.i_raw+%2B=+0x00800000+>>+exx;
++++++++if+(exx+==+0)+ex_mask+>>=+1;
++++++++raw.i_raw+&=+~ex_mask;
++++};
++++return++raw.f_raw;
};|263744|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|$]]

round_f for ARM with math
<pre><code>static inline float round_f(float value)
{
 float rep;
 asm volatile (&quot;vrinta.f32 %0,%1&quot; : &quot;=t&quot;(rep) : &quot;t&quot;(value));
 return rep;
}
</code></pre>
round_f for ARM without math
<pre><code>union f__raw {
 struct {
 uint32_t massa :23;
 uint32_t order :8;
 uint32_t sign :1;
 };
 int32_t i_raw;
 float f_raw;
};

float round_f(float value)
{
 union f__raw raw;
 int32_t exx;
 uint32_t ex_mask;
 raw.f_raw = value;
 exx = raw.order - 126;
 if (exx &lt; 0) {
 raw.i_raw &amp;= 0x80000000;
 } else if (exx &lt; 24) {
 ex_mask = 0x00ffffff &gt;&gt; exx;
 raw.i_raw += 0x00800000 &gt;&gt; exx;
 if (exx == 0) ex_mask &gt;&gt;= 1;
 raw.i_raw &amp;= ~ex_mask;
 };
 return raw.f_raw;
};
</code></pre>

I need a simple floating point rounding function, thus: 

<pre><code>double round(double);

round(0.1) = 0
round(-0.1) = 0
round(-0.9) = -1
</code></pre>

I can find <code>ceil()</code> and <code>floor()</code> in the math.h - but not <code>round()</code>.

Is it present in the standard C++ library under another name, or is it missing??

round() for float in C++

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我需要一个简单的浮点四舍五入函数，因此：double round(double);round(0.1) = 0round(-0.1) = 0round(-0.9) = -1我可以在math.h中找到ceil()和floor() --但round()找不到。它是以另一个名称出现在标准C++库中，还是丢失了？？

问C++中的float的round()
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中的float的round()EN