difference between ~0U and ~0 | C Programming (2024)

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.

Hello All,

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

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

Click to expand...

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

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

Click to expand...

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

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

Click to expand...

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

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

Click to expand...

See Also

Bachelor Psychologie - Open Universiteit - Open Universiteit

~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.

Click to expand...

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.

Click to expand...

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.

Click to expand...

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 ?

Click to expand...

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

S

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.

Click to expand...

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

somenath said:

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.

Click to expand...

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.

Close, but backwards.

~0 is all bit 1.

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

Click to expand...

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.

pete said:

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.

Click to expand...

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

Remember, only 22 more shopping days before March 32.