shift operation on a negative number.

[avee137]

please explain shift operation on negative numbers.
i executed a demo as below:

char c=-1,d,e;
d=c<<9;
e=c>>9;

it yields d=0 ,which i could understand as it works like a normal shift operation where bits are discarded as they move out of the word and bits on right side get filled by all 0's,

and e=-1,
and this i could not figure out as even after shifting it by 9 bits it holds the value intact.


any relevant explanation or reference would be a great help.

[laserlight]

it yields d=0 ,which i could understand as it works like a normal shift operation where bits are discarded as they move out of the word and bits on right side get filled by all 0's,

Strictly speaking, the behaviour is undefined. Using ** to denote exponentation:

The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with zeros. If E1 has an unsigned type, the value of the result is E1 * 2**E2, reduced modulo one more than the maximum value representable in the result type. 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.

and e=-1,
and this i could not figure out as even after shifting it by 9 bits it holds the value intact.

The result is implementation defined.

The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1 / 2**E2. If E1 has a signed type and a negative value, the resulting value is implementation-defined.

Generally, I prefer to work with unsigned integer types when dealing with bitwise operations.

[avee137]

Thank you.

[GReaper]

Doesn't the compiler use logical shift for unsigned ints and arithmetic shift for signed ones?

[dwks]

That would be a reasonable way to do it, but not all compilers are required to do so.

It would certainly explain the phenomena that (-1 >> 9) is still -1. An arithmetic right shift shifts in a copy of the most significant (leftmost) bit. So if two's complement representation is used then -1 will be represented with all bits set to 1, e.g. 0xffffffff (on a 32-bit machine). Performing an arithmetic right-shift will shift out some 1's on the right, but the new bits shifted in will be 1's as well because the original MSB was 1. If a logical right-shift were performed then zeros are shifted in no matter what; so a right-shift by four bits would in this case be 0x0fffffff.

The reasoning behind arithmetic left-shifts is quite simple: it preserves the negativeness of numbers. -4 right-shifted by 1 will be -2, which when right-shifted by 1 will be -1. Shifting in zeros in this case would have strange results if you were interpreting the bits as a signed number.