这个问题的答案取决于你工作的环境。

If you're working on an 8-bit microcontroller or anything without hardware support for multiplication, bit shifting is expected and commonplace, and while the compiler will almost certainly turn x /= 2 into x >>= 1, the presence of a division symbol will raise more eyebrows in that environment than using a shift to effect a division. If you're working in a performance-critical environment or section of code, or your code could be compiled with compiler optimization off, x >>= 1 with a comment explaining its reasoning is probably best just for clarity of purpose. If you're not under one of the above conditions, make your code more readable by simply using x /= 2. Better to save the next programmer who happens to look at your code the 10 second double-take on your shift operation than to needlessly prove you knew the shift was more efficient sans compiler optimization.

所有这些假设都是无符号整数。简单的移位可能不是你想要的符号。此外，DanielH提出了一个关于在ActionScript等特定语言中使用x *= 0.5的好观点。

哪一个是最好的选择，为什么整数除以2?

这取决于你对最佳的定义。

如果你想让你的同事讨厌你，或者让你的代码难以阅读，我肯定会选择第一个选择。

如果你想把一个数除以2，就用第二个数。

这两者是不等价的，如果数字是负的或在更大的表达式中，它们的行为是不一样的——bitshift的优先级比+或-低，除法的优先级更高。

您应该编写代码来表达其意图。如果您关心的是性能，不要担心，优化器在这类微优化方面做得很好。

我想说有几件事需要考虑。

Bitshift should be faster, as no special computation is really needed to shift the bits, however as pointed out, there are potential issues with negative numbers. If you are ensured to have positive numbers, and are looking for speed then I would recommend bitshift. The division operator is very easy for humans to read. So if you are looking for code readability, you could use this. Note that the field of compiler optimization has come a long way, so making code easy to read and understand is good practice. Depending on the underlying hardware, operations may have different speeds. Amdal's law is to make the common case fast. So you may have hardware that can perform different operations faster than others. For example, multiplying by 0.5 may be faster than dividing by 2. (Granted you may need to take the floor of the multiplication if you wish to enforce integer division).

如果您追求的是纯粹的性能，我建议您创建一些可以执行数百万次操作的测试。对执行进行多次采样(您的样本量)，以确定哪一个在统计上最适合您的操作系统/硬件/编译器/代码。

我们有很多理由支持使用x = x / 2;以下是一些例子:

it expresses your intent more clearly (assuming you're not dealing with bit twiddling register bits or something) the compiler will reduce this to a shift operation anyway even if the compiler didn't reduce it and chose a slower operation than the shift, the likelihood that this ends up affecting your program's performance in a measurable way is itself vanishingly small (and if it does affect it measurably, then you have an actual reason to use a shift) if the division is going to be part of a larger expression, you're more likely to get the precedence right if you use the division operator: x = x / 2 + 5; x = x >> 1 + 5; // not the same as above signed arithmetic might complicate things even more than the precedence problem mentioned above to reiterate - the compiler will already do this for you anyway. In fact, it'll convert division by a constant to a series of shifts, adds, and multiplies for all sorts of numbers, not just powers of two. See this question for links to even more information about this.

简而言之，当你真正想要进行乘法或除法运算时，编写移位代码并没有什么好处，除了可能会增加引入错误的可能性。自从编译器不够聪明到在适当的时候优化这类事情到移位以来，已经过去了。

使用除法(/)，假设这样更清楚。编译器将相应地进行优化。

我同意其他答案，你应该支持x / 2，因为它的意图更清楚，编译器应该为你优化它。

然而，选择x / 2而不是x >> 1的另一个原因是，如果x是一个有符号int并且是负的，那么>>的行为是依赖于实现的。

ISO C99标准第6.5.7节第5项:

E1 >> E2的结果是E1位右移E2位位置。如果E1 无符号类型，或者E1有符号类型且值为非负值， 结果值为E1 /商的积分部分 2 e2。如果E1具有符号类型和负值，则结果值为 是由实现定义的。