64位系统下的size_t（-1）和int（-1）

Question

I wrote a test code for verifying some issues of 64-bit porting. But I was confused with the following cases:

size_t size_neg_one = (size_t(-1));
int int_neg_one = -1;
printf("size_neg_one = %#zu, int_neg_one = %#x\n", size_neg_one, int_neg_one);

The output result is:

size_neg_one = 0xffffffffffffffff
int_neg_one  = 0xffffffff

Obviously, size_neg_one shouldn't equal to int_neg_one . But I tried if(size_neg_one == int_neg_one) and got TRUE . It doesn't match my expectation.

Could someone explain this condition for me? Thanks in advance.

My DEV environment: with .

Answer 1

6.3.1.3 Signed and unsigned integers

1 When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged.
2 Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type.60)
3 Otherwise, the new type is signed and the value cannot be represented in it; either the result is implementation-defined or an implementation-defined signal is raised.

So int (32Bit 2-s complement) is converted to size_t (64Bit unsigned), by adding 2^64 to -1.

Just about every compiler will warn about such a comparison though.

Answer 2

Most binary operators, including == , work on two values with the same type. If the two types are different, then one or both is promoted so that they match.

The rules are quite complicated but, in this case, int_neg_one is promoted to size_t . This uses exactly the same conversion as the cast used to give size_neg_one its value, and so the comparison compares two equal values and yields true .

Answer 3

当您将size_t与INT进行比较时，其中一个会隐式转换为另一个。

Answer 4

Firstly, your printf is broken. It produces undefined behavior. You used %x format specifier with an int argument. %x requires unsigned int argument, not an int argument. While this combination might still be legal for a non-negative int value, it is not defined for negative values. In other words, the int_neg_one = 0xffffffff output you observe has no particular meaning in the language. The output is rather obviously meaningless, since the positive value 0xffffffff is out of range of type int on your platform.

Secondly, as for size_neg_one == int_neg_one equality, as other have already explained, according to the rules of the language the comparison is performed in the domain of unsigned type size_t , meaning that your comparison is actually interpreted as

size_neg_one == size_t(int_neg_one)

The right-hand size produces the same value as your size_t(-1) , which is why the equality holds.

Answer 5

In order to compare values, both operands must have the same type, which is determined by a somewhat complex set of rules; in particular, in this case, in the unlikely case that size_t is smaller than int , the rules are different than if it is the same size or larger. Assuming the usual case, however, where size_t is larger than or the same size as int , the int will be converted into size_t . Since size_t is guaranteed to be an unsigned integral type, if the integral type is negative, the results of the conversion are defined as the mathematical correct results of std::numeric_limits<size_t>::max() + 1 + int_value . (The mathematically correct results, because within C++, the results of std::numeric_limits<size_t>::max() + 1 are guaranteed to be 0.)