By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
445,819 Members | 1,185 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 445,819 IT Pros & Developers. It's quick & easy.

comparing signed and unsigned integers

P: n/a
What bad things could happen if I compare signed and unsigned integers?
(is that even valid C?)

Thanks,
Joe
Jun 23 '06 #1
Share this Question
Share on Google+
3 Replies


P: n/a
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.8), 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
might be a "bad thing."

--
Eric Sosman
es*****@acm-dot-org.invalid

Jun 23 '06 #2

P: n/a
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 ---
Jun 25 '06 #3

P: n/a

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
addressed the issue.

Tom

Jun 25 '06 #4

This discussion thread is closed

Replies have been disabled for this discussion.