Printable View
can someone make it clear for me please ?
if i say
the output will be :Code:int a = 0xFFFFFFFF;
unsigned int b = 0xFFFFFFFF;
printf("a = %d, b = %u" , a,b);
a = -1 , b = 4294967295
// now . FFFF FFFF is 1111 1111 and 'int a' has the first 1 as the flag for negetive number .
. how its works. someone can figure it out for me ?
Simply put, 0xFF = 1111 1111 is the 2s complement for -1. Look up 2s complement. It's an encoding scheme used in computers.
Note, also, that C implementations are not required to use 2s-complement encoding - and there are certainly implementations that don't. The result could therefore be different with different implementations (compiler, host system, etc).
Also be aware that true 2s-complement has a representation for negative zero, which is distinct from positive zero. The modified 2s-complement used in most systems you're likely to encounter does not.Quote:
Originally Posted by Elysia
O_oQuote:
Also be aware that true 2s-complement has a representation for negative zero, which is distinct from positive zero.
I think you are looking for "One's Complement" where "Two's Complement" is the one without the negative zero.
Soma
You're right. My mistake.
To be clear, 0xffffffff is not -1, it is 4294967295. This value may or may not be representable by an int or an unsigned int (see 5.2.4.2.1p1). When the value cannot be represented by an int, converting it to an int has implementation-defined behaviour (see 6.3.1.3p3).
No, it's not. A number is a string of bits. What number those string of bits represents depends on how you interpret them.Quote:
Originally Posted by zyxwvuts
If you interpret it as an unsigned number, then it's 4..294..967..295.
If you interpret it as a two's complement number, then it's -1.
The point I was trying to convey is that C will interpret the integer constant (not the representation) 0xffffffff as having the value that is commonly written as 4294967295. (See 6.4.4.1p4.)
That's just it though, it doesn't because int's are signed.Quote:
Originally Posted by zyxwvuts
0xffffffffU does though.
O_oQuote:
That's just it though, it doesn't because int's are signed.
The "signedness" of `int' has nothing to do with the comment zyxwvuts posted.
Integer literals are not necessarily `int'; they are "first fit" according to a few rules.
If the compiler supports larger--such as 64bit--values, the value `0xffffffff' as an `int' is naturally 4294967295 decimal.
When a compiler is limited smaller--such as 32bit--values, the value `0xffffffff' may be too large for a `int'--which is signed. A conforming compiler will then try `unsigned int', `long', and so on until an appropriate type is found. If one of the unsigned types "first fit", the value of `0xffffffff' would be treated as unsigned thus still being 4294967295 decimal.
[Edit]
Tried to clear up some awkward wording...
[/Edit]
Soma