Thread: logical shift and arithmetic shift.(bit shifting in C )

From what I'm told, right shifting of signed integers on some machine cause 1's to be shifted in and on others 0's are shifted in. Now for a signed integer, say -32, is only the last one shifted in as a 1 if its multiple shifts to the right?

And if its shifting in zeros, how does it know its negative without the 1 in the most significant bit spot? Can someone give me an example of this?

Just do not use the shifting of signed values and you will have no need to understand the undefined behavior caused by it.

Originally Posted by vart

Just do not use the shifting of signed values and you will have no need to understand the undefined behavior caused by it.

Actually isn't this implementation defined behavior, not undefined behavior?

what about the on bits that are shifted in?

The bits shifted in are 0's.

Jim

Originally Posted by A34Chris

Yes its dropping it down by a factor of two but what about the on bits that are shifted in? I'm confused.

Just try this

Code:

#include <stdio.h>

void print_bits(int value ) {
   unsigned int mask = 1 << 31;
   int i;
   printf("\n%12d = ", value );
   for( i = 31; i >= 0; --i ) {
      printf("%c", value & mask ? '1' : '0' );
      mask >>= 1;
   }
}

int main() {
    int v = 123;
    print_bits( v );
    print_bits( v >> 2);
    puts("");
    v = -123;
    print_bits( v );
    print_bits( v >> 2);
    puts("");
    return 0;
}

my output

Code:

         123 = 00000000000000000000000001111011
          30 = 00000000000000000000000000011110

        -123 = 11111111111111111111111110000101
         -31 = 11111111111111111111111111100001

The only thing that might be a little confusing is that shifting -123 two positions to the right gives -31. But that is how integer truncation is defined. it gives the next lower value.

Kurt

Originally Posted by jimblumberg

Actually isn't this implementation defined behavior, not undefined behavior?
The bits shifted in are 0's.

You're contradicting yourself! It is, as you say, implementation defined, so it's not always 0's.

The bits shifted in are 0's if the sign bit is 0 no matter what the implementation's choice between arithmetic or logical shifts.

But if the number is negative, then an arithmetic shift will shift in 1's while a logical shift will still shift in 0's. Thus, an arithmetic shift retains the sign of the number.

So to tell which one your machine uses (my guess is arithmetic!), just take a negative number, shift it one place right, and see if it's still negative.

Code:

int n = -1;
n >>= 1;
puts((n < 0) ? "arithmetic" : "logical");