why shift int a=1 to left 31 bits then to right 31 bits, it becomes -1

Question

given

int a = 1; (00000000000000000000000000000001),

what I did is just

a=(a<<31)>>31;

I assume a should still be 1 after this statement (nothing changed I think). However, it turns out to be -1 (11111111111111111111111111111111). Anyone knows why?

Look up sign extension. And then try it again with an unsigned int. — ClickRick, Apr 23 '15 at 23:27
That answer refers to operator `>>>` which is definitely not a C++ operator so I don't think it's a duplicate. — Mark B, Apr 23 '15 at 23:33
@ShaneNian Why are you keep rolling back my edits, that improved your questions formatting? — πάντα ῥεῖ, Apr 23 '15 at 23:33
Assuming 2³¹ can be represented in `unsigned`, but not `int`, even `a<<31` is an implementation-defined result, before the right shift even comes into play. — chris, Apr 23 '15 at 23:50
Removed duplicate link to general bitshifting question, `1 << 31` is special case that is not covered in the top answers — M.M, Jul 23 '17 at 21:11

score 5 · Accepted Answer · answered Apr 23 '15 at 23:35

5

What you are missing is that in C++ right shift >> is implementation defined. It could either be logical or arithmetic shift for a signed value. In this case it's shifting in 1s from the left to retain the sign of the shifted value. Typically you want to avoid doing shifts on signed values unless you know precisely that they will be positive or that the shift implementation doesn't matter.

answered Apr 23 '15 at 23:35

Mark B

95,107
10
109
188

`1 << 31` is also implementation-defined ([ref](https://stackoverflow.com/questions/26331035/why-was-1-31-changed-to-be-implementation-defined-in-c14)) – M.M Jul 23 '17 at 21:13

score 3 · Answer 2 · answered Apr 23 '15 at 23:41

Look at it in steps:

#include <cstdio>
using namespace std;

int main()
{
    int a = 1;
    printf("%d = %x\n", a, a);
    a <<= 31;
    printf("%d = %x\n", a, a);
    a >>= 31;
    printf("%d = %x\n", a, a);
    return 0;
}

Output:

1 = 1
-2147483648 = 80000000
-1 = ffffffff

1 got shifted all the way up to the high bit which makes it a negative number. Shifting back down triggers sign extension to maintain the negative.

Change the declaration of a to unsigned int a and you will get the behaviour you expect.

score 2 · Answer 3 · answered Apr 23 '15 at 23:30

2

" however it turns out to be -1"

You use an unsigned int to do so for seeing only 32 bit values that are greater than 0:

 unsigned int a = 1; 
 a=(a<<31)>>31;

answered Apr 23 '15 at 23:30

πάντα ῥεῖ

1
13
116
190

score 0 · Answer 4 · answered Apr 23 '15 at 23:31

It is a signed shift so the left most bit will be extended. That way the overall number is on the same side of 0.

By left shifting that much you put the lowest bit into the sign bit and end up with a negative number.

When you then do a right shift it sign extends, copying the sign bit down to the lower 31 bits.

If you want to know the lowest bit just do & 1.

why shift int a=1 to left 31 bits then to right 31 bits, it becomes -1

4 Answers4

Linked

Related