Conversion between signed integer and unsigned int

Question

If I cast an unsigned integer to a signed integer then cast back, am I guaranteed to get the original value? For example, does this function always return true for any x on any platform according to the C++ standard?

bool f(unsigned int x)
{
    return x == static_cast<unsigned int>(static_cast<int>(x));
}

What about this one?

bool g(int x)
{
    return x == static_cast<int>(static_cast<unsigned int>(x));
}

Answer 1

The answer is "no, this is not guaranteed" for both f and g.

Here is what the standard says about it:

4.7 Integral conversions

2. If the destination type is unsigned, the resulting value is the least unsigned integer congruent to the source integer (modulo 2ⁿ where n is the number of bits used to represent the unsigned type). [ Note: In a two’s complement representation, this conversion is conceptual and there is no change in the bit pattern (if there is no truncation). — end note ]
3. If the destination type is signed, the value is unchanged if it can be represented in the destination type; otherwise, the value is implementation-defined.

Section 2 talks about function g. The cast of x to unsigned can cause change of representation on systems that do not use two's complement representation, so converting the number back may get you a different value.

Section 3 talks about function f. When the number is outside signed int's range, the result is implementation-defined, so one is not allowed to make any claims about the result of converting it back to unsigned.