How to deal with “signed/unsigned mismatch” warnings (C4018, no loop)?

Question

There are similar questions here but they related to particular case of usage in loop indexes. This one is more generic case. How to deal with this warning if there is no loops?

How to deal with the warning in this simplified case to outline the problem?

int(-3) >= size_t(31)

I would say the best way is to always use correct data types — SingerOfTheFall, Mar 06 '17 at 09:53
What is the purpose of the expression you show? What is the *actual* problem you try to solve with that expression? That expression by itself and without context is useless. — Some programmer dude, Mar 06 '17 at 09:54
You may check this http://stackoverflow.com/questions/13600991/why-is-a-negative-int-greater-than-unsigned-int — Chen OT, Mar 06 '17 at 10:20
@SingerOfTheFall types are correct (first signed and second unsigned) and correspond to different protocols and need to know which value is bigger. — Sergei Krivonos, May 10 '17 at 14:00

Martin Bonner supports Monica · Answer 1 · 2017-03-06T10:16:49.190

Cast at least one of the operands so that they are both of the same signedness.

Be careful when casting unsigned to signed: if the value is too large, you will get implementation defined behaviour.

Be careful when casting signed to unsigned - the behaviour when the original value is negative is precisely defined, but it may be surprising. If the expression is rewritten as size_t(-3) >= size_t(31) then it is always true.

Note that the cast to int in the example is pointless - the literal 3 must be of type int, and applying unary - to that will give an int result.

score 2 · Answer 2 · answered Mar 06 '17 at 10:03

It is a case-by-case basis, and you just have to use your knowledge of the problem you're solving to make that call. The goal is to avoid logic errors at runtime, not to stamp out warning messages.

Casting one or the other value to be the same as the other removes the warning, but won't prevent runtime problems due to logic errors.

e.g. if you had a large unsigned value and cast that to be signed, then it flips negative, which would mess up comparisions. Conversely, flipping -3 to unsigned will make it into a very large positive value, which would mess up the comparison you're trying. Sure, explicitly casting the values could avoid the messages but those messages are warning you about possible unexpected behaviour from your program, which you need to consider carefully regarding the possible & likely values that these variables can take.

Actually, if you have a *large* unsigned value and cast it be signed, then the behaviour is implementation defined. It *may* flip negative, but it might also saturate at the largest possible int (or just return zero). — Martin Bonner supports Monica, Mar 06 '17 at 10:16

score 0 · Accepted Answer · answered May 10 '17 at 13:58

To get answer which value is bigger use signed arbitrary arithmetic types like boost::cpp_int

auto v1 = int(-3);
auto v2 = size_t(31);
boost::cpp_int(v1) >= boost::cpp_int(v2);

If you have access to 80bit MMX registers then consider using them to store both values as signed and compare.

How to deal with “signed/unsigned mismatch” warnings (C4018, no loop)?

3 Answers3