Velocity Reviews > comparing signed and unsigned integers

# comparing signed and unsigned integers

Joe Van Dyk
Guest
Posts: n/a

 06-23-2006
What bad things could happen if I compare signed and unsigned integers?
(is that even valid C?)

Thanks,
Joe

Eric Sosman
Guest
Posts: n/a

 06-23-2006
Joe Van Dyk wrote:

> What bad things could happen if I compare signed and unsigned integers?
> (is that even valid C?)

Second question first: Yes, it is valid. The operands are
subject to the "usual arithmetic conversions" (6.3.1., which
reconcile them to a common type. The comparison is then carried
out in that common type.

First question second: The usual arithmetic conversions may
result in a type that is surprising to the novice, changing the
"obvious" meaning of the expression:

int i = -1;
unsigned int u = i + 1;
if (u > i) ...

Clearly, u is initialized to a value greater than that of i:
after all, i is negative and u is zero, so u must be greater
than i, right? Not so, Grasshopper: after the "usual arithmetic
conversions" (which in this case convert both operands to
unsigned int), the converted i will be UINT_MAX, much *larger*
than u. If you don't understand what's happening, the result

--
Eric Sosman
http://www.velocityreviews.com/forums/(E-Mail Removed)lid

Joe Wright
Guest
Posts: n/a

 06-25-2006
Joe Van Dyk wrote:
> What bad things could happen if I compare signed and unsigned integers?
> (is that even valid C?)
>
> Thanks,
> Joe

Besides nasal demons?

First, why would you mix signed and unsigned int values for comparison?

These are two different animals and generally shouldn't be compared.

But if you must, check the int for < 0. If negative, there's your answer
because unsigned is >= 0 by definition.

Now, if the int is positive, cast it to unsigned and do the comparison.

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

Tom St Denis
Guest
Posts: n/a

 06-25-2006

Joe Wright wrote:
> Joe Van Dyk wrote:
> > What bad things could happen if I compare signed and unsigned integers?
> > (is that even valid C?)
> >
> > Thanks,
> > Joe

>
> Besides nasal demons?
>
> First, why would you mix signed and unsigned int values for comparison?
>
> These are two different animals and generally shouldn't be compared.
>
> But if you must, check the int for < 0. If negative, there's your answer
> because unsigned is >= 0 by definition.
>
> Now, if the int is positive, cast it to unsigned and do the comparison.

My usual solution is to actually review the code. If I know the value
never has to be tested for >= 0 [e.g. decrementing loop] or negative I
convert it to unsigned locally.

Otherwise, I look at the values and use good common sense... e.,g.

int x;
unsigned char myarray[100];
for (x = 0; x < sizeof(myarray); x++) { myarray[x] = 0; }

That will generate the diagnostic with GCC. The fix I use (if I can't
move x to unsigned) is to just realize that myarray is less than the
minimum size for an int and cast the sizeof. e.g.

for (x = 0; x < (int)sizeof(myarray); x++) { ... }

I don't do the cast to "fix" the code, it's just my way of
acknowledging the diagnostic and signalling to myself that I've

Tom