Printing unsigned long long using %d

Question

Why do I get -1 when I print the following?

unsigned long long int largestIntegerInC = 18446744073709551615LL;

printf ("largestIntegerInC = %d\n", largestIntegerInC);

I know I should use llu instead of d, but why do I get -1 instead of 18446744073709551615LL?

Is it because of overflow?

Answer 1

In two's complement arithmetic, the signed value -1 is the same as the largest unsigned value.

Consider the bit patterns for negative numbers in two's complement (I'm using 8 bit integers, but the pattern applies regardless of the size):

 0 - 0x00
-1 - 0xFF
-2 - 0xFE
-3 - 0xFD

So, you can see that negative 1 has the bit pattern of all 1's which is also the bit pattern for the largest unsigned value.

Answer 2

You used a format for a signed 32-bit number, so you got -1. printf() can't tell internally how big the number you passed in is, so it just pulls the first 32 bits from the varargs list and uses them as the value to be printed out. Since you gave a signed format, it prints it that way, and 0xffffffff is the two's complement representation of -1.

Answer 3

It's because you're passing a number with all the bits set to 1. When interpreted as a two's complement signed number, that works out to -1. In this case, it's probably only looking at 32 of those one bits instead of all 64, but that doesn't make any real difference.

Answer 4

You can (should) see why in compiler warning. If not, try to set the highest warning level. With VS I've got this warning: warning C4245: 'initializing' : conversion from '__int64' to 'unsigned __int64', signed/unsigned mismatch.

Answer 5

No, there is no overflow. It's because it isn't printing the entire value:

18446744073709551615 is the same as 0xFFFFFFFFFFFFFFFF. When printf %d processes that, it grabs only 32 bits (or 64 bits if it's a 64-bit CPU) for conversion, and those are the signed value -1.

If the printf conversion had been %u instead, it would show either 4294967295 (32 bits) or 18446744073709551615 (64 bits).

An overflow is when a value increases to the point where it won't fit in the storage allocated. In this case, the value is allocated just fine, but isn't being completely retrieved.