首先，错误条件(multiple == 0)应该有一个返回值。什么?我不知道。也许您想要抛出一个异常，这取决于您。但是，什么都不返回是危险的。

其次，您应该检查numToRound是否已经是一个倍数。否则，当您在roundDown中添加倍数时，您将得到错误的答案。

第三，你的角色选择是错误的。您将numToRound转换为一个整数，但它已经是一个整数。需要在除法之前强制转换为to double，在乘法之后强制转换回int。

最后，负数需要什么?舍入“向上”可以表示舍入到零(与正数方向相同)，或远离零(一个“更大”的负数)。或者，也许你不在乎。

以下是前三个修复的版本，但我不处理负面问题:

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);
}

想要一个简短而甜蜜的答案的人。这是我用的。不考虑消极因素。

n - (n % r)

这将返回前一个因子。

(n + r) - (n % r)

将返回下一个。希望这能帮助到一些人。：）

/// 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) );
}}
}

四舍五入到2的幂:

以防有人需要一个正数四舍五入到2的幂的最近倍数的解(因为这就是我在这里结束的原因):

// number: the number to be rounded (ex: 5, 123, 98345, etc.)
// pow2:   the power to be rounded to (ex: to round to 16, use '4')
int roundPow2 (int number, int pow2) {
    pow2--;                     // because (2 exp x) == (1 << (x -1))
    pow2 = 0x01 << pow2;

    pow2--;                     // because for any
                                //
                                // (x = 2 exp x)
                                //
                                // subtracting one will
                                // yield a field of ones
                                // which we can use in a
                                // bitwise OR

    number--;                   // yield a similar field for
                                // bitwise OR
    number = number | pow2;
    number++;                   // restore value by adding one back

    return number;
}

如果输入的数字已经是一个倍数，那么它将保持不变。

以下是GCC使用- o2或- os给出的x86_64输出(9Sep2013 Build - godbolt GCC online):

roundPow2(int, int):
    lea ecx, [rsi-1]
    mov eax, 1
    sub edi, 1
    sal eax, cl
    sub eax, 1
    or  eax, edi
    add eax, 1
    ret

每一行C代码都与它在程序集中的行完全对应:http://goo.gl/DZigfX

每条指令都非常快，所以这个函数也非常快。由于代码非常小且快速，因此在使用时内联该函数可能很有用。

信贷:

算法:Hagen von Eitzen @ Math。SE Godbolt交互式编译器:@mattgodbolt/gcc-explorer在GitHub上

如果x已经是一个倍数，我使用模的组合来取消余数的加法:

int round_up(int x, int div)
{
    return x + (div - x % div) % div;
}

我们求余数的倒数然后再用除数求模如果它是除数本身，再加上x。

round_up(19, 3) = 21

c:

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

对于~/.bashrc:

roundup()
{
  echo $(( ${2} ? ((${1}+${2}-1)/${2})*${2} : ${1} ))
}