Why unsigned int 0xFFFFFFFF is equal to int -1?

by

C and C++ can run on many different architectures, and machine types. Consequently, they can have different representations of numbers: Two’s complement, and Ones’ complement being the most common. In general you should not rely on a particular representation in your program.

For unsigned integer types (size_t being one of those), the C standard (and the C++ standard too, I think) specifies precise overflow rules. In short, if SIZE_MAX is the maximum value of the type size_t, then the expression

(size_t) (SIZE_MAX + 1)

is guaranteed to be 0, and therefore, you can be sure that (size_t) -1 is equal to SIZE_MAX. The same holds true for other unsigned types.

Note that the above holds true:

  • for all unsigned types,
  • even if the underlying machine doesn’t represent numbers in Two’s complement. In this case, the compiler has to make sure the identity holds true.

Also, the above means that you can’t rely on specific representations for signed types.

Edit: In order to answer some of the comments:

Let’s say we have a code snippet like:

int i = -1;
long j = i;

There is a type conversion in the assignment to j. Assuming that int and long have different sizes (most [all?] 64-bit systems), the bit-patterns at memory locations for i and j are going to be different, because they have different sizes. The compiler makes sure that the values of i and j are -1.

Similarly, when we do:

size_t s = (size_t) -1

There is a type conversion going on. The -1 is of type int. It has a bit-pattern, but that is irrelevant for this example because when the conversion to size_t takes place due to the cast, the compiler will translate the value according to the rules for the type (size_t in this case). Thus, even if int and size_t have different sizes, the standard guarantees that the value stored in s above will be the maximum value that size_t can take.

If we do:

long j = LONG_MAX;
int i = j;

If LONG_MAX is greater than INT_MAX, then the value in i is implementation-defined (C89, section 3.2.1.2).

More Related Contents:

  1. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?
  2. How do you convert decimal in integer to hexadecimal in integer? [closed]
  3. Why it is so ? And It is without you explicitly do casting [duplicate]
  4. When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?
  5. Why use static_cast(x) instead of (int)x?
  6. When to use reinterpret_cast?
  7. Is const_cast safe?
  8. What is the difference between static_cast and C style casting?
  9. Is it safe to use -1 to set all bits to true?
  10. How is a variable at the same address producing 2 different values? [duplicate]
  11. How do I avoid implicit conversions on non-constructing functions?
  12. Modifying a const through a non-const pointer
  13. Function pointers casting in C++
  14. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  15. error: cast from ‘void*’ to ‘int’ loses precision
  16. Implicit conversion from char** to const char**
  17. C++ – Decimal to binary converting
  18. Can a cast operator be explicit?
  19. What is the difference between C-like casting and functional casting? [duplicate]
  20. Why is “operator void” not invoked with cast syntax?
  21. C++ class member function pointer to function pointer
  22. Efficient bitwise operations for counting bits or find the right|left most ones
  23. std::lexical_cast – is there such a thing?
  24. Handling overflow when casting doubles to integers in C
  25. Fastest way to Convert String to Binary?
  26. Is casting std::pair const& to std::pair const& safe?
  27. Should I use a C++ reinterpret_cast over a C-style cast?
  28. What is the modern, correct way to do type punning in C++?
  29. How to cast simple pointer to a multidimensional-array of fixed size?
  30. How can I extend a lexical cast to support enumerated types?

Leave a Comment