好吧——我几乎不好意思在这里张贴这个(如果有人投票关闭，我会删除)，因为这似乎是一个基本的问题。
这是在c++中四舍五入到一个数字的倍数的正确方法吗?
我知道还有其他与此相关的问题，但我特别感兴趣的是，在c++中做这件事的最佳方法是什么:
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);
}
更新:
抱歉，我可能没把意思说清楚。下面是一些例子:
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
以下是我根据OP的建议和其他人给出的例子给出的解决方案。因为大多数人都在寻找它来处理负数，这个解决方案就是这样做的，而不使用任何特殊的功能，如腹肌等。
通过避免使用模数而使用除法，负数是一个自然的结果，尽管它是四舍五入。在计算出向下舍入的版本之后，它会执行所需的数学运算以向上舍入，或者向负方向舍入，或者向正方向舍入。
还要注意的是，没有使用特殊的函数来计算任何东西，所以这里有一个小的速度提升。
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 + multiple;
}
以下是我根据OP的建议和其他人给出的例子给出的解决方案。因为大多数人都在寻找它来处理负数，这个解决方案就是这样做的，而不使用任何特殊的功能，如腹肌等。
通过避免使用模数而使用除法，负数是一个自然的结果，尽管它是四舍五入。在计算出向下舍入的版本之后，它会执行所需的数学运算以向上舍入，或者向负方向舍入，或者向正方向舍入。
还要注意的是，没有使用特殊的函数来计算任何东西，所以这里有一个小的速度提升。
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 + multiple;
}
公认的答案并不是很好，我想我应该在这个问题上尝试一下，这应该是你抛出的所有整数:
int round_up(int input, unsigned int multiple) {
if (input < 0) { return input - input % multiple; }
return input + multiple - (((input - 1) % multiple) + 1);
}
如果这个数是负的，这很简单，取余数并把它加到输入上，这就可以了。
如果这个数不是负的，你必须从倍数中减去余数，然后加上它来四舍五入。问题是，如果输入正好在一个倍数上，它仍然会四舍五入到下一个倍数，因为倍数- 0 =倍数。
为了解决这个问题，我们做了一个很酷的小技巧:在计算余数之前从输入中减去1，然后把它加回到结果的余数上。这不会影响任何东西，除非输入是倍数。在这种情况下，减去1将计算出前一个倍数的余数。再加1，就正好是这个倍数。很明显，从自身减去这个等于0，所以输入值不变。
/// 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->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) );
}}
}
