Why does -INT_MIN = INT_MIN in a signed, two’s complement representation?

by

One way to think about it is that signed, two’s complement format works by assigning each bit a power of two, then flipping the sign of the last power of two. Let’s look at -4, for example, which is represented as 100. This means that the value is

-1 x 2^2 + 0 x 2^1 + 0 x 2^0

If we want to get the positive version of this value, we’d have to negate it to get

 1 x 2^2 - 0 x 2^1 - 0 x 2^0

Notice that this value is equal to

 1 x 2^2 + 0 x 2^1 + 0 x 2^0

In other words, the normal binary representation of this value is 100. However, we’re in trouble here, because we’re using a signed two’s complement representation, which means that we have specifically reserved the 4’s bit as the sign bit. Consequently, when we try to interpret the bit pattern 100 as a signed, three-bit, two’s complement value, it comes back out identically to what we started with. The shortage of bits is what’s hurting here.

More generally, given n bits, of which the first is the sign bit in a two’s complement representation, trying to compute -1000…00 will give back the same value, because the bit needed to store the large positive value has the special meaning assigned to it.

So why do this at all? The reason for this is that if you have only n bits, you cannot store the values -2n – 1 through 2n – 1, because there are 2n + 1 different numbers here and only 2^n different bit patterns. Excluding the largest positive number thus makes it possible to hold all the different numbers in the bit pattern specified.

But why drop the high value and not the low value? This is in order to preserve binary compatibility with unsigned integers. In an unsigned integer, the values 0 through 2n-1 – 1 are all encoded using the standard base-two representation. Consequently, for unsigned and signed integers to agree at all, the unsigned integers are designed so that they are bit-for-bit equivalent with the first 2n – 1 unsigned integers, which range from 0 to 2n – 1 – 1, inclusive. After this, the unsigned values need the most significant bit to encode numbers, but the signed values are using this as the sign bit.

Hope this helps!

More Related Contents:

  1. How do you convert decimal in integer to hexadecimal in integer? [closed]
  2. Write a c++ function that will prompt a user for an integer and convert it to binary and print in reverse order [duplicate]
  3. Explanation of shift operationals use in condition
  4. Leading zeros of a binary number doesn’t get printed
  5. C++ convert hex string to signed integer
  6. Signed/unsigned comparisons
  7. Can I use a binary literal in C or C++?
  8. What happens if I assign a negative value to an unsigned variable?
  9. Reading and writing binary file
  10. How to print (using cout) a number in binary form?
  11. Detecting signed overflow in C/C++
  12. Is it safe to use -1 to set all bits to true?
  13. Iteration over std::vector: unsigned vs signed index variable
  14. Using -1 as a flag value for unsigned (size_t) types
  15. Read binary data from std::cin
  16. Why unsigned int 0xFFFFFFFF is equal to int -1?
  17. How to reverse an std::string? [duplicate]
  18. C++ – Decimal to binary converting
  19. Why does this if condition fail for comparison of negative and positive integers [duplicate]
  20. How to do serialization of Class having members of custom data types in C++? [closed]
  21. Converting string of 1s and 0s into binary value
  22. Efficient bitwise operations for counting bits or find the right|left most ones
  23. How do I deal with “signed/unsigned mismatch” warnings (C4018)?
  24. Ramifications of C++20 requiring two’s complement
  25. Fastest way to Convert String to Binary?
  26. Difference between opening a file in binary vs text [duplicate]
  27. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  28. How is an integer stored in memory?
  29. Signedness of enum in C/C99/C++/C++x/GNU C/GNU C99
  30. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?

Leave a Comment