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

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的好观点。

x / 2更清晰，x >> 1快不了多少(根据一个微基准测试，对于Java JVM快30%左右)。正如其他人所注意到的，对于负数，舍入略有不同，所以当您想处理负数时必须考虑这一点。一些编译器可能会自动将x / 2转换为x >> 1，如果他们知道这个数字不可能是负数(即使我无法验证这一点)。

即使x / 2可能不使用(慢)除法CPU指令，因为一些捷径是可能的，但它仍然比x >> 1慢。

(This is a C / C++ question, other programming languages have more operators. For Java there is also the unsigned right shift, x >>> 1, which is again different. It allows to correctly calculate the mean (average) value of two values, so that (a + b) >>> 1 will return the mean value even for very large values of a and b. This is required for example for binary search if the array indices can get very large. There was a bug in many versions of binary search, because they used (a + b) / 2 to calculate the average. This doesn't work correctly. The correct solution is to use (a + b) >>> 1 instead.)

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

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

ISO C99标准第6.5.7节第5项:

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

一般右移分为:

q = i >> n; is the same as: q = i / 2**n;

这有时被用来加快程序的速度，但以清晰度为代价。我觉得你不应该这么做。编译器足够智能，可以自动执行加速。这意味着，以清晰度为代价，你不会获得任何好处。

看看《实用c++编程》的这一页。

我们有很多理由支持使用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.

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

使用最能描述您要做的事情的操作。

如果你将数字作为一个比特序列来处理，请使用bitshift。 如果你把它当作一个数值，使用除法。

请注意，它们并不完全相等。对于负整数，它们可以给出不同的结果。例如:

-5 / 2  = -2
-5 >> 1 = -3

(ideone)