将 unsigned int 绑定到 signed int 引用是否安全？

Question

After coming across something similar in a co-worker's code, I'm having trouble understanding why/how this code executes without compiler warnings or errors.

#include <iostream>

int main (void)
{
    unsigned int u = 42;

    const int& s = u;

    std::cout << "u=" << u << " s=" << s << "\n";

    u = 6 * 9;

    std::cout << "u=" << u << " s=" << s << "\n";
}

Output:

u=42 s=42
u=54 s=42

First, I expect the compiler to issue some kind of diagnostic when I mix signed/unsigned integers like this. Certainly it does if I attempt to compare with < . That's one thing that confuses me.

Second, I'm not sure how the second line of output is generated. I expected the value of s to be 54. How does this work? Is the compiler creating an anonymous, automatic signed integer variable, assigning the value of u , and pointing the reference s at that value? Or is it doing something else, like changing s from a reference to a plain integer variable?

Answer 1

References can't bind to objects with different type directly. Given const int& s = u; , u is implicitly converted to int firstly, which is a temporary and then s binds to the temporary int . (Lvalue-references to const (and rvalue-references) could bind to temporaries.) The lifetime of the temporary is prolonged to the lifetime of s , ie it'll be destroyed when get out of main .

Answer 2

Both int and unsigned int are stored in the memory as 4 bytes with total of 32-bits (May vary according to the used compiler) to represent their values in binary form of base-2.
The main difference between them is that the regular int reserves the most significant bit (The 32 ^nd bit) for the sign magnitude where:
0 means positive integer and 1 mean negative integer.
and therefore int can carry values up to 2^31 of positive and negative integers.
while the unsigned int uses the whole 32-bits allowing the variable to carry 2^32
Which is the double of what a normal int can hold. So exchanging values between int and unsigned int is fine as long as the value is positive and less than or equal to 2^31 assigning larger or negative values is possible but it will cause overflow and assign values that are different from the expected ones.