bit shift - Bit shifting an int 32 times in C

Question

I have a specific C bit-shifting scenario that I do not believe is covered on Stack Overflow yet. (If it is, I haven't been able to find it!)

This exercise is using signed ints as the data type.

Take the value 0x80000000 (which is just a 1 in the most significant bit.)

Shift it right once on a machine using arithmetic right-shifts (which mine does).

Result = 0xC0000000 (1100 0000 in leftmost byte).

Continue shifting it and you should be filling up with ones, from the left to the right.

Result = 0xFFFFFFFF (All ones.)

However: Try the same example but shift one extra position, all together:

0x80000000 >> 0x00000020 (Right shift 32 times)

Your result? I don't know. My result was not all ones. In fact, I got 0x00000001 which was NOT my desired behavior. Why is this? Is it machine specific?

(Context: Homework assignment limiting my operations to a few bit operators to solve a puzzle. This is an aspect to a puzzle but is far from the entire question.)

Answer 1

It's undefined behavior

Why doesn't left bit-shift, "<<", for 32-bit integers work as expected when used more than 32 times?

which means you should avoid it like the plague. Here's some links including "What every C programmer should know about undefined behavior": http://lwn.net/Articles/511767/