difference between ~0U and ~0

[somenath]

Hello All,

I am confused with the behaviour of the following program
#include<stdio.h>

int main(void)
{
printf("\n~0U = %d",~0U);
printf("\n~0 = %d",~0);
printf("\n~0U>>1 = %d",~0U>>1);
printf("\n~0>>1 = %d\n",~0>>1);
return 0;
}

==========
Output
=========

~0U = -1
~0 = -1
~0U>>1 = 2147483647
~0>>1 = -1
===========
According to my understanding ~0 is -1.So I will get all bit 1 as a
result of ~0 in 2's complement system.

So the first two line of output saying ~0 is same as ~0U. Then why
there is difference in the output of ~0U>>1 and ~0>>1 ?
please provide some input.

 

[Stephen Sprunk]

Hello All,

I am confused with the behaviour of the following program
#include<stdio.h>

int main(void)
{
printf("\n~0U = %d",~0U);

~0U has type (unsigned int); the appropriate format specifier is %u, not %d.

printf("\n~0 = %d",~0);

~0 has type (int), so %d is correct.

printf("\n~0U>>1 = %d",~0U>>1);

~0U>>1 has type (unsigned int); the appropriate format specifier is %u,
not %d.

printf("\n~0>>1 = %d\n",~0>>1);

~0>>1 has type (int), so %d is correct.

return 0;
}

==========
Output
=========

~0U = -1
~0 = -1
~0U>>1 = 2147483647
~0>>1 = -1
===========
According to my understanding ~0 is -1.

That is true for if the zero's type is signed. However, "0U" is
unsigned, so the result of the ~ operator cannot be negative.

So I will get all bit 1 as a result of ~0 in 2's complement system.

That is an implementation detail and will only confuse you at this point.

So the first two line of output saying ~0 is same as ~0U.

Perhaps on your system, but your code invokes undefined behavior by
using the wrong format specifier, so anything is possible.

Then why there is difference in the output of ~0U>>1 and ~0>>1 ?

Fix the bugs in your code and you'll see that you're asking the wrong
questions.

S

 

[BGB]

Hello All,

I am confused with the behaviour of the following program
#include<stdio.h>

int main(void)
{
printf("\n~0U = %d",~0U);
printf("\n~0 = %d",~0);
printf("\n~0U>>1 = %d",~0U>>1);
printf("\n~0>>1 = %d\n",~0>>1);
return 0;
}

==========
Output
=========

~0U = -1
~0 = -1
~0U>>1 = 2147483647
~0>>1 = -1
===========
According to my understanding ~0 is -1.So I will get all bit 1 as a
result of ~0 in 2's complement system.

So the first two line of output saying ~0 is same as ~0U. Then why
there is difference in the output of ~0U>>1 and ~0>>1 ?
please provide some input.

because ~0U is unsigned, but ~0 is signed.
'>>' does different things for signed and unsigned values.

 

[Ben Bacarisse]

I am confused with the behaviour of the following program
#include<stdio.h>

int main(void)
{
printf("\n~0U = %d",~0U);
printf("\n~0 = %d",~0);
printf("\n~0U>>1 = %d",~0U>>1);
printf("\n~0>>1 = %d\n",~0>>1);
return 0;
}

==========
Output
=========

~0U = -1
~0 = -1
~0U>>1 = 2147483647
~0>>1 = -1
===========
According to my understanding ~0 is -1.So I will get all bit 1 as a
result of ~0 in 2's complement system.

So the first two line of output saying ~0 is same as ~0U. Then why
there is difference in the output of ~0U>>1 and ~0>>1 ?
please provide some input.

I don't think anyone has said yet that the result of right shifting a
negative value is, explicitly, implementation-defined. Some machines
will do one things and some another. The C standard leaves it up to the
implementation to say what it does. The result of ~0U >> 1 is defined
by the language -- it must be UINT_MAX/2 (that's C's division
there, of course, not mathematical division) but ~0 >> 1 can be anything
the implementation chooses. The two most likely possibilities are
INT_MAX and -1.

 

[James Piper]

Close, but backwards.

~0 is all bit 1.

So you will get -1 as a
result of ~0 in 2's complement system.

That's true.

1 in 8-bit format is: 0000 0001
To get neg- 1:
1. Negate bits. 1111 1110
2. Add 1: 1111 11111

Same results regardless of the bit size.

 

[Tim Rentsch]

Another way for negatising in two's complement is:
1. subtract 1. 0000 0000
2. Negate bits: 1111 11111

I've worked on assembly code
that had it done either way in different parts of the code.
I don't know if it was done by the same person.

The first method turns x into -x; the second turns -x into x.

Remember, only 22 more shopping days before March 32.