Bitwise NOT operator returning unexpected and negative value? [duplicate]

Answer 1

And want to check every bit if it's 1 or 0.

To check an individual bit, you don't NOT the number, you AND it with an appropriate bit mask:

if ((x & 1) != 0) ... // bit 0 is 1
if ((x & 2) != 0) ... // bit 1 is 1
if ((x & 4) != 0) ... // bit 2 is 1
if ((x & 8) != 0) ... // bit 3 is 1
...
if ((x & (1 << n)) != 0) ... // bit n is 1
...
if ((x & 0x80000000) != 0) ... // bit 31 is 1

Answer 2

In two-complement arithmetic to get a reverse number (for example for value 16 to get value -16) you need reverse each bit and add 1.

In your example, to get -16 from 16 that is represented as

00000000000000000000000000010000

you need reverse each bit. You will get

11111111111111111111111111101111

Now you must add 1 and you will get

11111111111111111111111111110000

As you can see if you add these two values, you will get 0. It proves that you did all correctly.

Answer 3

Although there are pedantic points which can be made about compiler behaviour, the simple answer is that a signed int with the top bit set is a negative number.

So if you do something which sets the top bit of an int (a signed int, not an unsigned one), then ask the tools/library to show you the value of that int, you'll see a negative number.

This is not a universal truth, but it's a good approximation to it for most modern systems.

Note that it's printf which is making the representation here - because %d formats numbers as signed. %u may give the result you're expecting. Just changing the types of the variables won't be enough, because printf doesn't know anything about the types of its arguments.

I would say that as a general rule of thumb, if you're doing bit-twiddling, then use unsigned ints and display them in hexadecimal. Life will be simpler that way, and it most generally fits with the intent. (Fancy accelerated maths tricks are an obvious exception)

Answer 4

If you want to get ones' complement of a number, you need to put that number into an unsigned variable and show it as so. In C it would be:

unsigned int x = ~16;
printf("%u\n", x);

and you will get 4294967279. But if you are just trying to get the negative number of a certain one, put the - operator before it.

EDIT: To check whether a bit is 0 or 1, you have to use the bitwise AND.