Unsigned numbers: am I correct in my understanding?

Code Gurus,


I ran into a bug which was at first very hard to detect.

I figured it out later on but I want to make sure my assumption is correct about this problem.


Let's say we have an unsigned number

unsigned int x = 10;
int y = 20;


Let's say we have the code:

if( (x - y) < 0 )
{
// x - y is less than 0
}else
{
// x - y is greater than 0
}

This code will never enter into the if-block statement.
Why?

My assumption is that the terms (x - y) as a whole term is
evaluating as an unsigned number thus the value is greater than zero.

Am I correct in my understanding here?
What is going on?


Thanks.

you are correct. unsigned has precedence over signed.
if you need to use signed and unsigned with the same expression, then you should cast the unsigned into signed:

unsigned int uInt = ...
int sInt = ...

if( sInt > (int)uInt )
...

You could also reverse that:

if( (y-x) >= 0 ) ...

mwilliamson,

if( (y-x) >= 0 )
wont work since the expressions (y-x) and (x-y) are unsigned the result is always true even if y is negative.


Regards,
Guy

Guysl is correct. His example shows casting in C. If you're using C++, you'll want to use static_cast<T> (expr)

Thanks guys! Appreciate it.

I can't find the reference, and I can't remember if it was Stroustrup, Meyers or Sutter who said it, but I remember reading an article about unsigned within the last year or so. It contained a lot of supporting reasoning, but basically boiled down to: "don't use unsigned in arithmetic situations". Don't even use unsigned to indicate the your data is meant to be zero-positive. Reserve unsigned for things like bitmasks, where you are doing bitwise operations, not arithmetic.

Code:

---

void foo(unsigned int x);

int main()
{
    foo(-1);
}

void foo(unsigned int x)
{
    // Data validation - how?
}

---

Compare:

Code:

---

void foo(int x);

int main()
{
    foo(-1);
}

void foo(int x)
{
    if (x < 0)
        throw bad_argument();
    else
    {
    // ...
    }
}

---

If I remember correctly, the following is one of the example used to explain why we should avoid unsigned.

Code:

---

int main(void)
{
    unsigned i;
    for (i=10; i >= 0; i--)
    {
        printf(“i is %u\n”, i);
    }
    return 0;
}

---

The for-loop will not stop since the unsigned i will never be smaller than 0. Whenever i becomes zero, the next decrement causes it to become the largest unsigned value due to over/underflow.