comparing signed and unsigned integers

Discussion in 'C Programming' started by Joe Van Dyk, Jun 23, 2006.

  1. Joe Van Dyk

    Joe Van Dyk Guest

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

    Joe Van Dyk, Jun 23, 2006
    1. Advertisements

  2. Joe Van Dyk

    Eric Sosman Guest

    Second question first: Yes, it is valid. The operands are
    subject to the "usual arithmetic conversions" (, 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, Jun 23, 2006
    1. Advertisements

  3. Joe Van Dyk

    Joe Wright Guest

    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, Jun 25, 2006
  4. Joe Van Dyk

    Tom St Denis Guest

    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 St Denis, Jun 25, 2006
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.