带符号整数的算术位移。-Arithmeticbit-shiftonasignedinteger

47  

Right shift of a negative signed number has implementation-defined behaviour.

负签名数的右移具有实现定义的行为。

If your 8 bits are meant to represent a signed 8 bit value (as you're talking about a "signed 32 bit integer" before switching to 8 bit examples) then you have a negative number. Shifting it right may fill "empty" bits with the original MSB (i.e. perform sign extension) or it may shift in zeroes, depending on platform and/or compiler.

如果你的8位代表一个有符号的8位值(在切换到8位示例之前，你正在讨论一个“有符号的32位整数”)，那么你就有一个负数。将其右移可能会填满“空”位与原始的MSB(即执行符号扩展)，或者它可以在零中移动，这取决于平台和/或编译器。

(Implementation-defined behaviour means that the compiler will do something sensible, but in a platform-dependent manner; the compiler documentation is supposed to tell you what.)

(实现定义的行为意味着编译器会做一些有意义的事情，但是是以平台依赖的方式;编译器文档应该告诉你什么。

A left shift, if the number either starts out negative, or the shift operation would shift a 1 either to or beyond the sign bit, has undefined behaviour (as do most operations on signed values which cause an overflow).

一个左移，如果这个数字开始是负数，或者移位操作会将一个1移动到符号位或者超过符号位，就会有未定义的行为(对于导致溢出的符号值的大多数操作也是如此)。

(Undefined behaviour means that anything at all could happen.)

(未定义的行为意味着任何事情都可能发生。)

The same operations on unsigned values are well-defined in both cases: the "empty" bits will be filled with 0.

在两种情况下，对未签名值的相同操作都是定义良好的:“空”位将填充为0。

32  

Bitwise shift operations are not defined for negative values

位移位操作不是为负值定义的。

for '<<'

“<<”

6.5.7/4 [...] If E1 has a signed type and nonnegative value, and E1×2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.

6.5.7/4[…)如果E1签署类型和非负价值,在结果和E1×2 e2表示的类型,那么得到的值;否则，行为是未定义的。

and for '>>'

和“> >”

6.5.7/5 [...] If E1 has a signed type and a negative value, the resulting value is implementation- defined.

6.5.7/5[…]如果E1有一个符号类型和一个负值，则生成的值是实现定义的。

It's a waste of time to study the behaviour of these operations on signed numbers on a specific implementation, because you have no guarantee it will work the same way on any other implementation (an implementation is, for example, you compiler on your computer with your specific commad-line parameters).

研究这些操作在特定实现上的签名数字的行为是浪费时间，因为您不能保证它在任何其他实现上的工作方式都是相同的(例如，您的计算机上的编译器会使用特定的逗号行参数)。

It might not even work for an older or a newer version of the very same compiler. The compiler might even define those bits as random or undefined. This would mean that the very same code sequence could produce totally different results when used across your sources or even depend on things like assembly optimisation or other register usage. If encapsulated in a function it might not even produce the same result in those bits on two consecutive calls with the same arguments.

它甚至可能不会为更老的版本或同一编译器的新版本工作。编译器甚至可以将这些位定义为随机的或未定义的。这意味着，当使用不同的源代码时，相同的代码序列可能产生完全不同的结果，甚至依赖于诸如组装优化或其他寄存器使用之类的东西。如果封装在一个函数中，它甚至可能不会在两个连续调用相同参数的情况下产生相同的结果。

Considering only non-negative values, the effect of left shifting by 1 (expression <<1) is the same as multpliying the expression by 2 (provided expression * 2 does not overflow) and the effect of right shifting by 1 (expression >> 1) is the same as dividing by 2.

仅考虑非负值的值，左移1(表达式<<1)的效果与2(提供的表达式* 2不溢出)和右移1(表达式>> 1)的效果相同，即除以2。

5  

As others said shift of negative value is implementation-defined.

正如其他人所说的，负值的转移是由实现定义的。

Most of implementations treat signed right shift as floor(x/2^N) by filling shifted in bits using sign bit. It is very convenient in practice, as this operation is so common. On the other hand if you will shift right unsigned integer, shifted in bits will be zeroed.

大多数实现将签名的右移作为层(x/2N)，用符号位填充移位。这在实践中非常方便，因为这个操作非常普遍。另一方面，如果你转换右无符号整数，移位的位将是零。

Looking from machine side, most implementations have two types of shift-right instructions:

从机器的角度来看，大多数实现都有两种类型的转换正确的指令:

1. An 'arithmetic' shift right (often having mnemonic ASR or SRA) which works as me explained.

   一种“算术”的右移(通常有助记符ASR或SRA)，正如我所解释的那样。

2. A 'logic' shift right (oftem having mnemonic LSR or SRL or SR) which works as you expect.

   一个“逻辑”的右移(oftem有助记符LSR或SRL或SR)，这是你所期望的。

Most of compilers utilize first for signed types and second for unsigned ones. Just for convenience.

大多数编译器首先使用已签名的类型，其次使用未签名的类型。只是为了方便。

0  

In the 32 bit compiler

在32位编译器中。

x = x >> 31;

x = x >> 31;

here x is the signed integer so 32nd bit is sign bit.

这里x是有符号整数，所以32位是符号位。

final x value is 100000...000. and 32nd bit indicate -ive value.

最后的x值是100000…000。第32位表示-ive值。

here x value implement to 1's compliment.

这里x值执行到1的恭维。

then final x is -32768

最后x是-32768。