Unsigned numbers: am I correct in my understanding?

[engineer2004]

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.

[Guysl]

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 )
...

[mwilliamson]

You could also reverse that:

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

[Guysl]

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

[kasracer]

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

[engineer2004]

Thanks guys! Appreciate it.

[Graham]

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.

void foo(unsigned int x);

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

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

Compare:

void foo(int x);

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

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

[Kheun]

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

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.