C++: Signed/unsigned mismatch when only using unsigned types
-
21-03-2021 - |
سؤال
When I try to compile the following C++ program using the Visual Studio 2010 C++ compiler (X86) with warning level /W4 enabled, I get a signed/unsigned mismatch warning at the marked line.
#include <cstdio>
#include <cstdint>
#include <cstddef>
int main(int argc, char **argv)
{
size_t idx = 42;
uint8_t bytesCount = 20;
// warning C4389: '==' : signed/unsigned mismatch
if (bytesCount + 1 == idx)
{
printf("Hello World\n");
}
// no warning
if (bytesCount == idx)
{
printf("Hello World\n");
}
}
This confuses me, since I'm only using unsigned types. Since the comparison
bytesCount == idx
causes no such warning, it probably has to do with some strange implicit conversation that happens here.
Thus: what is the reason why I get this warning and by what rules does this conversation happen (if this is the reason)?
المحلول
1
is an int
. The type of an integral arithmetic expression depends on the types involved. In this case, you have an unsigned
type and a signed
type where the unsigned
type is smaller than the signed
type. This falls under the C++ standard on expressions (section 5.10 [expr]):
Otherwise, if the type of the operand with signed integer type can represent all of the values of the type of the operand with unsigned integer type, the operand with unsigned integer type shall be converted to the type of the operand with signed integer type.
I.e., the type of the expression bytesCount + 1
is int
which is signed by default.
نصائح أخرى
1 is a signed literal. Try bytesCount + 1U.
The compiler is probably creating a temporary value of the signed type due to the addition of signed and unsigned values ( bytesCount + 1 )
Since 1 is of type int
the expression bytesCount + 1
is int
(signed).
In fact when a type smaller than int
is used in a mathematical expression it is promoted to int
, so even + bytesCount
and bytesCount + bytesCount
are considered int
and not uint8_t
(while bytesCount + 1U
is an unsigned int
since that is larger than int
).
The following program outputs true
three times.
#include <iostream>
int main()
{
unsigned short s = 1;
std::cout << (&typeid( s + 1U ) == &typeid(1U)) << std::endl;
std::cout << (&typeid( + s ) == &typeid(1)) << std::endl;
std::cout << (&typeid( s + s ) == &typeid(1)) << std::endl;
}
The other answers already tell you that bytesCount + 1
is interpreted as signed int
. However, I'd like to add that in bytesCount == idx
, bytesCount
is also interpreted as signed int
. Conceptually, it is first converted to signed int
, and it is only converted to unsigned int
after that. Your compiler does not warn about this, because it has enough information to know that there is not really problem. The conversion to signed int
cannot possibly make bytesCount
negative. Comparing bytesCount + 1
is equally valid, equally safe, but just that slight bit more complex to make the compiler no longer recognise it as safe.