blocks|key|965936|text|转换为浮点数并使用ceil()可能更安全-除非您知道int除法将产生正确的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|965937|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Probably safer to cast to floats and use ceil() - unless you know that the int division is going to produce the correct result.

blocks|key|965985|text|int+noOfMultiples+=+int((numToRound+/+multiple)%2B0.5);
return+noOfMultiples*multiple|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|965986|C%2B%2B将每个数字向下舍入，因此如果添加0.5+(如果是1.5，则为2)，但1.49将是1.99，因此为1。|unstyled|965987|编辑-很抱歉没有看到您想要四舍五入，我建议使用ceil()方法而不是%2B0.5|965988|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>int noOfMultiples = int((numToRound / multiple)+0.5);
return noOfMultiples*multiple
</code></pre>

C++ rounds each number down,so if you add 0.5 (if its 1.5 it will be 2) but 1.49 will be 1.99 therefore 1.

EDIT - Sorry didn't see you wanted to round up, i would suggest using a ceil() method instead of the +0.5

blocks|key|966058|text|首先，您的错误条件(多个==+0)应该有一个返回值。什么？我不知道。也许你想抛出一个异常，这由你决定。但是，不返回任何内容是危险的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966059|其次，您应该检查numToRound是否已经不是倍数。否则，当您向roundDown添加multiple时，您将得到错误的答案。|offset|length|style|CODE|966060|第三，您的演员阵容是错误的。您将numToRound强制转换为整数，但它已经是整数了。您需要在除法之前强制转换为double，并在乘法之后转换回int。|966061|最后，对于负数，你想要什么？向上舍入可能意味着舍入到零(以与正数相同的方向舍入)，或者远离零(一个“更大”的负数)。或者，也许你并不关心。|966062|这是一个包含前三个修复的版本，但我不会处理负面问题：|966063|int+roundUp(int+numToRound,+int+multiple)
{
+if(multiple+==+0)
+{
++return+0;
+}
+else+if(numToRound+%25+multiple+==+0)
+{
++return+numToRound
+}

+int+roundDown+=+(int)+((+(double)+numToRound+/+multiple+)+*+multiple);
+int+roundUp+=+roundDown+%2B+multiple;+
+int+roundCalc+=+roundUp;
+return+(roundCalc);
}|code-block|syntax|javascript|966064|entityMap^0|0|X|9|18|8|0|G|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|15|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

First off, your error condition (multiple == 0) should probably have a return value. What? I don't know. Maybe you want to throw an exception, that's up to you. But, returning nothing is dangerous.

Second, you should check that numToRound isn't already a multiple. Otherwise, when you add <code>multiple</code> to <code>roundDown</code>, you'll get the wrong answer.

Thirdly, your casts are wrong. You cast <code>numToRound</code> to an integer, but it's already an integer. You need to cast to to double before the division, and back to int after the multiplication.

Lastly, what do you want for negative numbers? Rounding "up" can mean rounding to zero (rounding in the same direction as positive numbers), or away from zero (a "larger" negative number). Or, maybe you don't care.

Here's a version with the first three fixes, but I don't deal with the negative issue:

<pre><code>int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
 return 0;
 }
 else if(numToRound % multiple == 0)
 {
 return numToRound
 }

 int roundDown = (int) (( (double) numToRound / multiple ) * multiple);
 int roundUp = roundDown + multiple; 
 int roundCalc = roundUp;
 return (roundCalc);
}
</code></pre>

blocks|key|966108|text|首先，因为我真的不明白你想做什么，台词|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966109|int+roundUp+=+roundDown+%2B+multiple;
int+roundCalc+=+roundUp;
return+(roundCalc);+|code-block|syntax|javascript|966110|绝对可以缩写为|966111|int+roundUp+=+roundDown+%2B+multiple;
return+roundUp;|966112|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|$]]

well for one thing, since i dont really understand what you want to do, the lines 

<pre><code>int roundUp = roundDown + multiple;
int roundCalc = roundUp;
return (roundCalc); 
</code></pre>

could definitely be shortened to 

<pre><code>int roundUp = roundDown + multiple;
return roundUp;
</code></pre>

blocks|key|966168|text|这是“我如何找出n比特将占用多少字节？”(A：(n比特%2B+7)+/+8)的问题的推广。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966169|int+RoundUp(int+n,+int+roundTo)
{
++++//+fails+on+negative?++What+does+that+mean?
++++if+(roundTo+==+0)+return+0;
++++return+((n+%2B+roundTo+-+1)+/+roundTo)+*+roundTo;+//+edit+-+fixed+error
}|code-block|syntax|javascript|966170|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 is a generalization of the problem of "how do I find out how many bytes n bits will take? (A: (n bits + 7) / 8).

<pre><code>int RoundUp(int n, int roundTo)
{
 // fails on negative? What does that mean?
 if (roundTo == 0) return 0;
 return ((n + roundTo - 1) / roundTo) * roundTo; // edit - fixed error
}
</code></pre>

blocks|key|966192|text|这适用于正数，但不确定负数。它只使用整数运算。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966193|int+roundUp(int+numToRound,+int+multiple)
{
++++if+(multiple+==+0)
++++++++return+numToRound;

++++int+remainder+=+numToRound+%25+multiple;
++++if+(remainder+==+0)
++++++++return+numToRound;

++++return+numToRound+%2B+multiple+-+remainder;
}|code-block|syntax|javascript|966194|编辑:这里有一个可以处理负数的版本，如果你说的“向上”是指一个总是>=输入的结果。|966195|int+roundUp(int+numToRound,+int+multiple)
{
++++if+(multiple+==+0)
++++++++return+numToRound;

++++int+remainder+=+abs(numToRound)+%25+multiple;
++++if+(remainder+==+0)
++++++++return+numToRound;

++++if+(numToRound+<+0)
++++++++return+-(abs(numToRound)+-+remainder);
++++else
++++++++return+numToRound+%2B+multiple+-+remainder;
}|966196|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|$]]

This works for positive numbers, not sure about negative. It only uses integer math.

<pre><code>int roundUp(int numToRound, int multiple)
{
 if (multiple == 0)
 return numToRound;

 int remainder = numToRound % multiple;
 if (remainder == 0)
 return numToRound;

 return numToRound + multiple - remainder;
}
</code></pre>

Edit: Here's a version that works with negative numbers, if by "up" you mean a result that's always >= the input.

<pre><code>int roundUp(int numToRound, int multiple)
{
 if (multiple == 0)
 return numToRound;

 int remainder = abs(numToRound) % multiple;
 if (remainder == 0)
 return numToRound;

 if (numToRound &lt; 0)
 return -(abs(numToRound) - remainder);
 else
 return numToRound + multiple - remainder;
}
</code></pre>

blocks|key|966210|text|int+roundUp(int+numToRound,+int+multiple)
{
+if(multiple+==+0)
+{
++return+0;
+}
+return+((numToRound+-+1)+/+multiple+%2B+1)+*+multiple;++
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|966211|也不需要在条件上乱搞|unstyled|966212|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>int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
 return 0;
 }
 return ((numToRound - 1) / multiple + 1) * multiple; 
}
</code></pre>

And no need to mess around with conditions

blocks|key|1180530|text|float+roundUp(float+number,+float+fixedBase)+{
++++if+(fixedBase+!=+0+&&+number+!=+0)+{
++++++++float+sign+=+number+>+0+?+1+:+-1;
++++++++number+*=+sign;
++++++++number+/=+fixedBase;
++++++++int+fixedPoint+=+(int)+ceil(number);
++++++++number+=+fixedPoint+*+fixedBase;
++++++++number+*=+sign;
++++}
++++return+number;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1180531|这适用于任何浮点数或基数(例如，您可以将-4舍入到最接近的6.75)。本质上它是转换成定点，四舍五入，然后再转换回来。它通过舍入0来处理负数。它还通过将函数本质上转换为roundDown来处理对值的负舍入。|unstyled|1180532|特定于int的版本如下所示：|1180533|int+roundUp(int+number,+int+fixedBase)+{
++++if+(fixedBase+!=+0+&&+number+!=+0)+{
++++++++int+sign+=+number+>+0+?+1+:+-1;
++++++++int+baseSign+=+fixedBase+>+0+?+1+:+0;
++++++++number+*=+sign;
++++++++int+fixedPoint+=+(number+%2B+baseSign+*+(fixedBase+-+1))+/+fixedBase;
++++++++number+=+fixedPoint+*+fixedBase;
++++++++number+*=+sign;
++++}
++++return+number;
}|1180534|这或多或少是plinth的答案，增加了负输入支持。|1180535|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>float roundUp(float number, float fixedBase) {
 if (fixedBase != 0 &amp;&amp; number != 0) {
 float sign = number &gt; 0 ? 1 : -1;
 number *= sign;
 number /= fixedBase;
 int fixedPoint = (int) ceil(number);
 number = fixedPoint * fixedBase;
 number *= sign;
 }
 return number;
}
</code></pre>

This works for any float number or base (e.g. you can round -4 to the nearest 6.75). In essence it is converting to fixed point, rounding there, then converting back. It handles negatives by rounding AWAY from 0. It also handles a negative round to value by essentially turning the function into roundDown.

An int specific version looks like:

<pre><code>int roundUp(int number, int fixedBase) {
 if (fixedBase != 0 &amp;&amp; number != 0) {
 int sign = number &gt; 0 ? 1 : -1;
 int baseSign = fixedBase &gt; 0 ? 1 : 0;
 number *= sign;
 int fixedPoint = (number + baseSign * (fixedBase - 1)) / fixedBase;
 number = fixedPoint * fixedBase;
 number *= sign;
 }
 return number;
}
</code></pre>

Which is more or less plinth's answer, with the added negative input support.

blocks|key|966326|text|当因子始终为正时，这是有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966327|int+round_up(int+num,+int+factor)
{
++++return+num+%2B+factor+-+1+-+(num+%2B+factor+-+1)+%25+factor;
}|code-block|syntax|javascript|966328|Edit:这将返回round_up(0,100)=100。有关返回round_up(0,100)=0的解决方案，请参阅下面的Paul注释。|offset|length|style|CODE|966329|entityMap^0|0|0|9|J|X|H|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

This works when factor will always be positive:
<pre><code>int round_up(int num, int factor)
{
 return num + factor - 1 - (num + factor - 1) % factor;
}
</code></pre>
Edit: This returns <code>round_up(0,100)=100</code>. Please see Paul's comment below for a solution that returns <code>round_up(0,100)=0</code>.

blocks|key|1180669|text|我发现了一个与上面发布的算法有点类似的算法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180670|int(%7Cx%7C%2Bn-1)/n*(nx)/%7Cx%7C，其中x是用户输入值，n是使用的倍数。|1180671|它适用于所有值x，其中x是整数(正数或负数，包括零)。我专门为C%2B%2B程序编写了它，但它基本上可以用任何语言实现。|1180672|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I found an algorithm which is somewhat similar to one posted above:

int[(|x|+n-1)/n]*[(nx)/|x|], where x is a user-input value and n is the multiple being used.

It works for all values x, where x is an integer (positive or negative, including zero). I wrote it specifically for a C++ program, but this can basically be implemented in any language.

blocks|key|966409|text|这对我很有效，但没有尝试处理负片|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966410|public+static+int+roundUp(int+numToRound,+int+multiple)+{
++++if+(multiple+==+0)+{
++++++++return+0;
++++}+else+if+(numToRound+%25+multiple+==+0)+{
++++return+numToRound;
++++}

++++int+mod+=+numToRound+%25+multiple;
++++int+diff+=+multiple+-+mod;
++++return+numToRound+%2B+diff;
}|code-block|syntax|javascript|966411|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 works for me but did not try to handle negatives

<pre><code>public static int roundUp(int numToRound, int multiple) {
 if (multiple == 0) {
 return 0;
 } else if (numToRound % multiple == 0) {
 return numToRound;
 }

 int mod = numToRound % multiple;
 int diff = multiple - mod;
 return numToRound + diff;
}
</code></pre>

blocks|key|1180738|text|对于负numToRound：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180739|这应该很容易做到，但是标准的模%25运算符并不像人们期望的那样处理负数。例如-14+%25+12+=+-2，而不是10。首先要做的是得到一个从不返回负数的模运算符。那么roundUp就非常简单了。|1180740|public+static+int+mod(int+x,+int+n)+
{
++++return+((x+%25+n)+%2B+n)+%25+n;
}

public+static+int+roundUp(int+numToRound,+int+multiple)+
{
++++return+numRound+%2B+mod(-numToRound,+multiple);
}|code-block|syntax|javascript|1180741|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|$]]

For negative numToRound:

It should be really easy to do this but the standard modulo % operator doesn't handle negative numbers like one might expect. For instance -14 % 12 = -2 and not 10. First thing to do is to get modulo operator that never returns negative numbers. Then roundUp is really simple.

<pre><code>public static int mod(int x, int n) 
{
 return ((x % n) + n) % n;
}

public static int roundUp(int numToRound, int multiple) 
{
 return numRound + mod(-numToRound, multiple);
}
</code></pre>

blocks|key|966508|text|为任何人寻找一个简短和甜蜜的答案。这就是我使用的。不考虑底片。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966509|n+-+(n+%25+r)|code-block|syntax|javascript|966510|这将返回前一个因子。|966511|(n+%2B+r)+-+(n+%25+r)|966512|将返回下一个。希望这对某些人有帮助。:)|966513|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

For anyone looking for a short and sweet answer. This is what I used. No accounting for negatives.

<pre><code>n - (n % r)
</code></pre>

That will return the previous factor.

<pre><code>(n + r) - (n % r)
</code></pre>

Will return the next. Hope this helps someone. :)

blocks|key|966572|text|这可能会有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966573|int+RoundUpToNearestMultOfNumber(int+val,+int+num)
{
++assert(0+!=+num);
++return+(floor((val+%2B+num)+/+num)+*+num);
}|code-block|syntax|javascript|966574|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|$]]

may be this can help:

<pre><code>int RoundUpToNearestMultOfNumber(int val, int num)
{
 assert(0 != num);
 return (floor((val + num) / num) * num);
}
</code></pre>

blocks|key|966593|text|///+Rounding+up+'n'+to+the+nearest+multiple+of+number+'b'.
///+-+Not+tested+for+negative+numbers.
///+\see+http://stackoverflow.com/questions/3407012/
#define+roundUp(n,b)+(+(b)==0+?+(n)+:+(+((n)%2B(b)-1)+-+(((n)-1)%25(b))+)+)

///+\c+test->roundUp().
void+test_roundUp()+{+++
++++//+yes_roundUp(n,b)+(+(b)==0+?+(n)+:+(+(n)%25(b)==0+?+n+:+(n)%2B(b)-(n)%25(b)+)+)
++++//+yes_roundUp(n,b)+(+(b)==0+?+(n)+:+(+((n+%2B+b+-+1)+/+b)+*+b+)+)

++++//+no_roundUp(n,b)+(+(n)%25(b)==0+?+n+:+(b)*(+(n)/(b)+)%2B(b)+)
++++//+no_roundUp(n,b)+(+(n)%2B(b)+-+(n)%25(b)+)

if+(true)+//+couldn't+make+it+work+without+(?:)
{{++//+test::roundUp()
++++unsigned+m;
++++++++++++++++{+m+=+roundUp(17,8);+}+%2B%2Bm;
++++assertTrue(+24+==+roundUp(17,8)+);
++++++++++++++++{+m+=+roundUp(24,8);+}
++++assertTrue(+24+==+roundUp(24,8)+);

++++assertTrue(+24+==+roundUp(24,4)+);
++++assertTrue(+24+==+roundUp(23,4)+);
++++++++++++++++{+m+=+roundUp(23,4);+}
++++assertTrue(+24+==+roundUp(21,4)+);

++++assertTrue(+20+==+roundUp(20,4)+);
++++assertTrue(+20+==+roundUp(19,4)+);
++++assertTrue(+20+==+roundUp(18,4)+);
++++assertTrue(+20+==+roundUp(17,4)+);

++++assertTrue(+17+==+roundUp(17,0)+);
++++assertTrue(+20+==+roundUp(20,0)+);
}}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|966594|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>/// Rounding up 'n' to the nearest multiple of number 'b'.
/// - Not tested for negative numbers.
/// \see http://stackoverflow.com/questions/3407012/
#define roundUp(n,b) ( (b)==0 ? (n) : ( ((n)+(b)-1) - (((n)-1)%(b)) ) )

/// \c test-&gt;roundUp().
void test_roundUp() { 
 // yes_roundUp(n,b) ( (b)==0 ? (n) : ( (n)%(b)==0 ? n : (n)+(b)-(n)%(b) ) )
 // yes_roundUp(n,b) ( (b)==0 ? (n) : ( ((n + b - 1) / b) * b ) )

 // no_roundUp(n,b) ( (n)%(b)==0 ? n : (b)*( (n)/(b) )+(b) )
 // no_roundUp(n,b) ( (n)+(b) - (n)%(b) )

if (true) // couldn't make it work without (?:)
{{ // test::roundUp()
 unsigned m;
 { m = roundUp(17,8); } ++m;
 assertTrue( 24 == roundUp(17,8) );
 { m = roundUp(24,8); }
 assertTrue( 24 == roundUp(24,8) );

 assertTrue( 24 == roundUp(24,4) );
 assertTrue( 24 == roundUp(23,4) );
 { m = roundUp(23,4); }
 assertTrue( 24 == roundUp(21,4) );

 assertTrue( 20 == roundUp(20,4) );
 assertTrue( 20 == roundUp(19,4) );
 assertTrue( 20 == roundUp(18,4) );
 assertTrue( 20 == roundUp(17,4) );

 assertTrue( 17 == roundUp(17,0) );
 assertTrue( 20 == roundUp(20,0) );
}}
}
</code></pre>

blocks|key|1180939|text|这就是我要做的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180940|#include+<cmath>

int+roundUp(int+numToRound,+int+multiple)
{
++++//+if+our+number+is+zero,+return+immediately
+++if+(numToRound+==+0)
++++++++return+multiple;

++++//+if+multiplier+is+zero,+return+immediately
++++if+(multiple+==+0)
++++++++return+numToRound;

++++//+how+many+times+are+number+greater+than+multiple
++++float+rounds+=+static_cast<float>(numToRound)+/+static_cast<float>(multiple);

++++//+determine,+whether+if+number+is+multiplier+of+multiple
++++int+floorRounds+=+static_cast<int>(floor(rounds));

++++if+(rounds+-+floorRounds+>+0)
++++++++//+multiple+is+not+multiplier+of+number+->+advance+to+the+next+multiplier
++++++++return+(floorRounds%2B1)+*+multiple;
++++else
++++++++//+multiple+is+multiplier+of+number+->+return+actual+multiplier
++++++++return+(floorRounds)+*+multiple;
}|code-block|syntax|javascript|1180941|代码可能不是最优的，但我更喜欢干净的代码而不是枯燥的性能。|1180942|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|$]]

This is what I would do:

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

int roundUp(int numToRound, int multiple)
{
 // if our number is zero, return immediately
 if (numToRound == 0)
 return multiple;

 // if multiplier is zero, return immediately
 if (multiple == 0)
 return numToRound;

 // how many times are number greater than multiple
 float rounds = static_cast&lt;float&gt;(numToRound) / static_cast&lt;float&gt;(multiple);

 // determine, whether if number is multiplier of multiple
 int floorRounds = static_cast&lt;int&gt;(floor(rounds));

 if (rounds - floorRounds &gt; 0)
 // multiple is not multiplier of number -&gt; advance to the next multiplier
 return (floorRounds+1) * multiple;
 else
 // multiple is multiplier of number -&gt; return actual multiplier
 return (floorRounds) * multiple;
}
</code></pre>

The code might not be optimal, but I prefer clean code than dry performance.

blocks|key|1180979|text|这将获得您正在寻找的正整数的结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180980|#include+<iostream>
using+namespace+std;

int+roundUp(int+numToRound,+int+multiple);

int+main()+{
++++cout+<<+"answer+is:+"+<<+roundUp(7,+100)+<<+endl;
++++cout+<<+"answer+is:+"+<<+roundUp(117,+100)+<<+endl;
++++cout+<<+"answer+is:+"+<<+roundUp(477,+100)+<<+endl;
++++cout+<<+"answer+is:+"+<<+roundUp(1077,+100)+<<+endl;
++++cout+<<+"answer+is:+"+<<+roundUp(52,20)+<<+endl;
++++cout+<<+"answer+is:+"+<<+roundUp(74,30)+<<+endl;
++++return+0;
}

int+roundUp(int+numToRound,+int+multiple)+{
++++if+(multiple+==+0)+{
++++++++return+0;
++++}
++++int+result+=+(int)+(numToRound+/+multiple)+*+multiple;
++++if+(numToRound+%25+multiple)+{
++++++++result+%2B=+multiple;
++++}+
++++return+result;
}|code-block|syntax|javascript|1180981|下面是输出：|1180982|answer+is:+100
answer+is:+200
answer+is:+500
answer+is:+1100
answer+is:+60
answer+is:+90|1180983|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|$]]

This is getting the results you are seeking for positive integers:

<pre><code>#include &lt;iostream&gt;
using namespace std;

int roundUp(int numToRound, int multiple);

int main() {
 cout &lt;&lt; "answer is: " &lt;&lt; roundUp(7, 100) &lt;&lt; endl;
 cout &lt;&lt; "answer is: " &lt;&lt; roundUp(117, 100) &lt;&lt; endl;
 cout &lt;&lt; "answer is: " &lt;&lt; roundUp(477, 100) &lt;&lt; endl;
 cout &lt;&lt; "answer is: " &lt;&lt; roundUp(1077, 100) &lt;&lt; endl;
 cout &lt;&lt; "answer is: " &lt;&lt; roundUp(52,20) &lt;&lt; endl;
 cout &lt;&lt; "answer is: " &lt;&lt; roundUp(74,30) &lt;&lt; endl;
 return 0;
}

int roundUp(int numToRound, int multiple) {
 if (multiple == 0) {
 return 0;
 }
 int result = (int) (numToRound / multiple) * multiple;
 if (numToRound % multiple) {
 result += multiple;
 } 
 return result;
}
</code></pre>

And here are the outputs:

<pre><code>answer is: 100
answer is: 200
answer is: 500
answer is: 1100
answer is: 60
answer is: 90
</code></pre>

blocks|key|1181047|text|这是使用模板函数的现代c%2B%2B方法，该模板函数适用于float、double、long、int和short+(但不适用于long+long和long+double，因为使用了双精度值)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181048|#include+<cmath>
#include+<iostream>

template<typename+T>
T+roundMultiple(+T+value,+T+multiple+)
{
++++if+(multiple+==+0)+return+value;
++++return+static_cast<T>(std::round(static_cast<double>(value)/static_cast<double>(multiple))*static_cast<double>(multiple));
}

int+main()
{
++++std::cout+<<+roundMultiple(39298.0,+100.0)+<<+std::endl;
++++std::cout+<<+roundMultiple(20930.0f,+1000.0f)+<<+std::endl;
++++std::cout+<<+roundMultiple(287399,+10)+<<+std::endl;
}|code-block|syntax|javascript|1181049|但您可以通过模板专门化轻松添加对long+long和long+double的支持，如下所示：|offset|length|style|CODE|1181050|template<>
long+double+roundMultiple<long+double>(+long+double+value,+long+double+multiple)
{
++++if+(multiple+==+0.0l)+return+value;
++++return+std::round(value/multiple)*multiple;
}

template<>
long+long+roundMultiple<long+long>(+long+long+value,+long+long+multiple)
{
++++if+(multiple+==+0.0l)+return+value;
++++return+static_cast<long+long>(std::round(static_cast<long+double>(value)/static_cast<long+double>(multiple))*static_cast<long+double>(multiple));
}|1181051|要创建向上舍入的函数，请使用std::ceil，并始终使用std::floor向下舍入。我上面的例子是使用std::round进行舍入。|1181052|创建“向上舍入”或更好地称为“圆形天花板”模板函数，如下所示：|1181053|template<typename+T>
T+roundCeilMultiple(+T+value,+T+multiple+)
{
++++if+(multiple+==+0)+return+value;
++++return+static_cast<T>(std::ceil(static_cast<double>(value)/static_cast<double>(multiple))*static_cast<double>(multiple));
}|1181054|创建“向下舍入”或更好地称为“圆形地板”模板函数，如下所示：|1181055|template<typename+T>
T+roundFloorMultiple(+T+value,+T+multiple+)
{
++++if+(multiple+==+0)+return+value;
++++return+static_cast<T>(std::floor(static_cast<double>(value)/static_cast<double>(multiple))*static_cast<double>(multiple));
}|1181056|entityMap^0|0|0|G|9|Q|B|0|0|E|9|T|A|1H|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$]]

This is the modern c++ approach using a template function which is working for float, double, long, int and short (but not for long long, and long double because of the used double values).

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

template&lt;typename T&gt;
T roundMultiple( T value, T multiple )
{
 if (multiple == 0) return value;
 return static_cast&lt;T&gt;(std::round(static_cast&lt;double&gt;(value)/static_cast&lt;double&gt;(multiple))*static_cast&lt;double&gt;(multiple));
}

int main()
{
 std::cout &lt;&lt; roundMultiple(39298.0, 100.0) &lt;&lt; std::endl;
 std::cout &lt;&lt; roundMultiple(20930.0f, 1000.0f) &lt;&lt; std::endl;
 std::cout &lt;&lt; roundMultiple(287399, 10) &lt;&lt; std::endl;
}
</code></pre>

But you can easily add support for <code>long long</code> and <code>long double</code> with template specialisation as shown below:

<pre><code>template&lt;&gt;
long double roundMultiple&lt;long double&gt;( long double value, long double multiple)
{
 if (multiple == 0.0l) return value;
 return std::round(value/multiple)*multiple;
}

template&lt;&gt;
long long roundMultiple&lt;long long&gt;( long long value, long long multiple)
{
 if (multiple == 0.0l) return value;
 return static_cast&lt;long long&gt;(std::round(static_cast&lt;long double&gt;(value)/static_cast&lt;long double&gt;(multiple))*static_cast&lt;long double&gt;(multiple));
}
</code></pre>

To create functions to round up, use <code>std::ceil</code> and to always round down use <code>std::floor</code>. My example from above is rounding using <code>std::round</code>.

Create the "round up" or better known as "round ceiling" template function as shown below:

<pre><code>template&lt;typename T&gt;
T roundCeilMultiple( T value, T multiple )
{
 if (multiple == 0) return value;
 return static_cast&lt;T&gt;(std::ceil(static_cast&lt;double&gt;(value)/static_cast&lt;double&gt;(multiple))*static_cast&lt;double&gt;(multiple));
}
</code></pre>

Create the "round down" or better known as "round floor" template function as shown below:

<pre><code>template&lt;typename T&gt;
T roundFloorMultiple( T value, T multiple )
{
 if (multiple == 0) return value;
 return static_cast&lt;T&gt;(std::floor(static_cast&lt;double&gt;(value)/static_cast&lt;double&gt;(multiple))*static_cast&lt;double&gt;(multiple));
}
</code></pre>

blocks|key|966840|text|c：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966841|int+roundUp(int+numToRound,+int+multiple)
{
++return+(multiple+?+(((numToRound%2Bmultiple-1)+/+multiple)+*+multiple)+:+numToRound);
}|code-block|syntax|javascript|966842|对于您的~/.bashrc：|966843|roundup()
{
++echo+$((+${2}+?+((${1}%2B${2}-1)/${2})*${2}+:+${1}+))
}|966844|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|$]]

c:

<pre><code>int roundUp(int numToRound, int multiple)
{
 return (multiple ? (((numToRound+multiple-1) / multiple) * multiple) : numToRound);
}
</code></pre>

and for your ~/.bashrc:

<pre><code>roundup()
{
 echo $(( ${2} ? ((${1}+${2}-1)/${2})*${2} : ${1} ))
}
</code></pre>

blocks|key|966902|text|我使用的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|966903|template+<class+_Ty>
inline+_Ty+n_Align_Up(_Ty+n_x,+_Ty+n_alignment)
{
++++assert(n_alignment+>+0);
++++//n_x+%2B=+(n_x+>=+0)?+n_alignment+-+1+:+1+-+n_alignment;+//+causes+to+round+away+from+zero+(greatest+absolute+value)
++++n_x+%2B=+(n_x+>=+0)?+n_alignment+-+1+:+-1;+//+causes+to+round+up+(towards+positive+infinity)
++++//n_x+%2B=+(_Ty(-(n_x+>=+0))+&+n_alignment)+-+1;+//+the+same+as+above,+avoids+branch+and+integer+multiplication
++++//n_x+%2B=+n_alignment+-+1;+//+only+works+for+positive+numbers+(fastest)
++++return+n_x+-+n_x+%25+n_alignment;+//+rounds+negative+towards+zero
}|code-block|syntax|javascript|966904|对于2的幂：|966905|template+<class+_Ty>
bool+b_Is_POT(_Ty+n_x)
{
++++return+!(n_x+&+(n_x+-+1));
}

template+<class+_Ty>
inline+_Ty+n_Align_Up_POT(_Ty+n_x,+_Ty+n_pot_alignment)
{
++++assert(n_pot_alignment+>+0);
++++assert(b_Is_POT(n_pot_alignment));+//+alignment+must+be+power+of+two
++++--+n_pot_alignment;
++++return+(n_x+%2B+n_pot_alignment)+&+~n_pot_alignment;+//+rounds+towards+positive+infinity+(i.e.+negative+towards+zero)
}|966906|请注意，这两个负值都舍入为零(这意味着所有值都舍入为正无穷大)，它们都不依赖于带符号溢出(这在C/C%2B%2B中未定义)。|966907|这提供了：|966908|n_Align_Up(10,+100)+=+100
n_Align_Up(110,+100)+=+200
n_Align_Up(0,+100)+=+0
n_Align_Up(-10,+100)+=+0
n_Align_Up(-110,+100)+=+-100
n_Align_Up(-210,+100)+=+-200
n_Align_Up_POT(10,+128)+=+128
n_Align_Up_POT(130,+128)+=+256
n_Align_Up_POT(0,+128)+=+0
n_Align_Up_POT(-10,+128)+=+0
n_Align_Up_POT(-130,+128)+=+-128
n_Align_Up_POT(-260,+128)+=+-256|966909|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I'm using:



<pre><code>template &lt;class _Ty&gt;
inline _Ty n_Align_Up(_Ty n_x, _Ty n_alignment)
{
 assert(n_alignment &gt; 0);
 //n_x += (n_x &gt;= 0)? n_alignment - 1 : 1 - n_alignment; // causes to round away from zero (greatest absolute value)
 n_x += (n_x &gt;= 0)? n_alignment - 1 : -1; // causes to round up (towards positive infinity)
 //n_x += (_Ty(-(n_x &gt;= 0)) &amp; n_alignment) - 1; // the same as above, avoids branch and integer multiplication
 //n_x += n_alignment - 1; // only works for positive numbers (fastest)
 return n_x - n_x % n_alignment; // rounds negative towards zero
}
</code></pre>

and for powers of two:

<pre><code>template &lt;class _Ty&gt;
bool b_Is_POT(_Ty n_x)
{
 return !(n_x &amp; (n_x - 1));
}

template &lt;class _Ty&gt;
inline _Ty n_Align_Up_POT(_Ty n_x, _Ty n_pot_alignment)
{
 assert(n_pot_alignment &gt; 0);
 assert(b_Is_POT(n_pot_alignment)); // alignment must be power of two
 -- n_pot_alignment;
 return (n_x + n_pot_alignment) &amp; ~n_pot_alignment; // rounds towards positive infinity (i.e. negative towards zero)
}
</code></pre>

Note that both of those round negative values towards zero (that means round to positive infinity for all values), neither of them relies on signed overflow (which is undefined in C/C++).

This gives:

<pre><code>n_Align_Up(10, 100) = 100
n_Align_Up(110, 100) = 200
n_Align_Up(0, 100) = 0
n_Align_Up(-10, 100) = 0
n_Align_Up(-110, 100) = -100
n_Align_Up(-210, 100) = -200
n_Align_Up_POT(10, 128) = 128
n_Align_Up_POT(130, 128) = 256
n_Align_Up_POT(0, 128) = 0
n_Align_Up_POT(-10, 128) = 0
n_Align_Up_POT(-130, 128) = -128
n_Align_Up_POT(-260, 128) = -256
</code></pre>

blocks|key|966996|text|如果x已经是一个倍数，我使用模数的组合来使余数的加法无效：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|966997|int+round_up(int+x,+int+div)
{
++++return+x+%2B+(div+-+x+%25+div)+%25+div;
}|code-block|syntax|javascript|966998|我们找到余数的倒数，然后用除数再次取模，如果它是除数本身，则添加x。|966999|round_up(19,+3)+=+21|967000|entityMap^0|2|1|0|0|W|1|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

I use a combination of modulus to nullify the addition of the remainder if <code>x</code> is already a multiple:

<pre><code>int round_up(int x, int div)
{
 return x + (div - x % div) % div;
}
</code></pre>

We find the inverse of the remainder then modulus that with the divisor again to nullify it if it is the divisor itself then add <code>x</code>.

<pre><code>round_up(19, 3) = 21
</code></pre>

blocks|key|1181349|text|这是我的解决方案，基于OP的建议，以及其他所有人给出的例子。因为大多数人都在寻找它来处理负数，所以这个解决方案就是这样做的，而不使用任何特殊的函数，例如abs等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181350|通过避免模数而使用除法，负数是一个自然的结果，尽管它是向下舍入的。在计算完向下舍入的版本后，它会执行所需的数学运算来向上舍入，无论是在负方向还是在正方向。|1181351|还要注意的是，没有使用特殊的函数来计算任何东西，所以有一个小的速度提升。|1181352|int+RoundUp(int+n,+int+multiple)
{
++++//+prevent+divide+by+0+by+returning+n
++++if+(multiple+==+0)+return+n;

++++//+calculate+the+rounded+down+version
++++int+roundedDown+=+n+/+multiple+*+multiple;

++++//+if+the+rounded+version+and+original+are+the+same,+then+return+the+original
++++if+(roundedDown+==+n)+return+n;

++++//+handle+negative+number+and+round+up+according+to+the+sign
++++//+NOTE:+if+n+is+<+0+then+subtract+the+multiple,+otherwise+add+it
++++return+(n+<+0)+?+roundedDown+-+multiple+:+roundedDown+%2B+multiple;
}|code-block|syntax|javascript|1181353|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's my solution based on the OP's suggestion, and the examples given by everyone else. Since most everyone was looking for it to handle negative numbers, this solution does just that, without the use of any special functions, i.e. abs, and the like.

By avoiding the modulus and using division instead, the negative number is a natural result, although it's rounded down. After the rounded down version is calculated, then it does the required math to round up, either in the negative or positive direction.

Also note that no special functions are used to calculate anything, so there is a small speed boost there.

<pre><code>int RoundUp(int n, int multiple)
{
 // prevent divide by 0 by returning n
 if (multiple == 0) return n;

 // calculate the rounded down version
 int roundedDown = n / multiple * multiple;

 // if the rounded version and original are the same, then return the original
 if (roundedDown == n) return n;

 // handle negative number and round up according to the sign
 // NOTE: if n is &lt; 0 then subtract the multiple, otherwise add it
 return (n &lt; 0) ? roundedDown - multiple : roundedDown + multiple;
}
</code></pre>

blocks|key|1181405|text|我想这应该会对你有帮助。我已经用C写了下面的程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181406|#+include+<stdio.h>
int+main()
{
++int+i,+j;
++printf("\nEnter+Two+Integers+i+and+j...");
++scanf("%25d+%25d",+&i,+&j);
++int+Round_Off=i%2Bj-i%25j;
++printf("The+Rounded+Off+Integer+Is...%25d\n",+Round_Off);
++return+0;
}|code-block|syntax|javascript|1181407|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 think this should help you. I have written the below program in C.

<pre><code># include &lt;stdio.h&gt;
int main()
{
 int i, j;
 printf("\nEnter Two Integers i and j...");
 scanf("%d %d", &amp;i, &amp;j);
 int Round_Off=i+j-i%j;
 printf("The Rounded Off Integer Is...%d\n", Round_Off);
 return 0;
}
</code></pre>

blocks|key|967214|text|这里有一个非常简单的解决方案来展示优雅的概念。它主要用于网格捕捉。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|967215|(伪代码)|967216|nearestPos+=+Math.Ceil(+numberToRound+/+multiple+)+*+multiple;|code-block|syntax|javascript|967217|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|$]]

Here is a super simple solution to show the concept of elegance. It's basically for grid snaps.
(pseudo code)
<pre><code>nearestPos = Math.Ceil( numberToRound / multiple ) * multiple;
</code></pre>

blocks|key|967252|text|我认为这是可行的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|967253|int+roundUp(int+numToRound,+int+multiple)+{
++++return+multiple?+!(numToRound%25multiple)?+numToRound+:+((numToRound/multiple)%2B1)*multiple:+numToRound;
}|code-block|syntax|javascript|967254|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 think this works:
<pre><code>int roundUp(int numToRound, int multiple) {
 return multiple? !(numToRound%multiple)? numToRound : ((numToRound/multiple)+1)*multiple: numToRound;
}
</code></pre>

blocks|key|967328|text|无限的可能性，仅适用于有符号整数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|967329|N%2B+((r+-+n)+%25+r)|967330|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Endless possibilities, for signed integers only:
n + ((r - n) % r)

OK - I'm almost embarrassed posting this here (and I will delete if anyone votes to close) as it seems like a basic question.

Is this the correct way to round up to a multiple of a number in C++? 

I know there are other questions related to this but I am specficially interested to know what is the best way to do this in C++:

<pre><code>int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
 return numToRound;
 }

 int roundDown = ( (int) (numToRound) / multiple) * multiple;
 int roundUp = roundDown + multiple; 
 int roundCalc = roundUp;
 return (roundCalc);
}
</code></pre>

Update:
Sorry I probably didn't make intention clear. Here are some examples:

<pre><code>roundUp(7, 100)
//return 100

roundUp(117, 100)
//return 200

roundUp(477, 100)
//return 500

roundUp(1077, 100)
//return 1100

roundUp(52, 20)
//return 60

roundUp(74, 30)
//return 90
</code></pre>

Rounding up to the nearest multiple of a number

OK -我几乎很尴尬地在这里张贴这篇文章(如果有人投票关闭，我将删除)，因为这似乎是一个基本的问题。在C++中，这是向上舍入到数字的倍数的正确方法吗？我知道还有其他与此相关的问题，但我特别感兴趣的是，在C++中做这件事的最佳方法是什么：int roundUp(int numToRound, int multiple){...

问向上舍入到数字的最接近的倍数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问向上舍入到数字的最接近的倍数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问向上舍入到数字的最接近的倍数
EN