The differences are max values and what they can store, basically. A signed number lets you store negative values - the sign representing positive or negative. Therefore, if you wanted the value '-30' you'd want a signed value. Unsigned values only allow positive values.

Signed numbers store their sign by using a bit of the variable to store positive or negative - if the bit is 1 then the value is negative, otherwise it's positive. This means that they will always have a smaller max value than their unsigned equivalent as they're not using the entire variable to store the value. For example, a signed 16-bit variable has the max value 2^15 but an unsigned variable has 2^16 (as it doesn't have to use a bit to say whether the number is negative).

EDIT: Just so it's clear - both can store the same range of values (for 16 bits = 65536), it's just the the maximum values are shifted. The signed number goes from –32768 to 32767 and the unsigned goes from 0 to 65536. Both ranges are the same, but the maximum value for the unsigned value is larger (65536 versus 32767). (This is the same for any data type, I just couldn't be bothered writing out the example for 32 bits ).

Use unsigned numbers where possible. They're quicker for the CPU to deal with and make more sense in some uses (for example, to store sizes and counts). The maximum value is higher too, which may be relevant in some cases. The only two times you'll want to use signed integers is when you expect a negative value and when you want to avoid converting between signed and unsigned values (which may require extending the result to a larger type, which will be slow).

[edited by - Alimonster on July 29, 2002 6:42:28 AM]

... and using unsigned integers prevents you checking for things like negative array indicies and memory allocation sizes.....

Couple of things to add here:
Signed and unsigned variables are treated completely differently when bit-shifting right. Signed variables will sign-extend the high bit: it will pad the high bits with zeros if the original high bit was zero, and it will pad the high bits with ones if the original high bit was one. If your variable is unsigned, you''ll always get zeros padded when right-shifting.

Also, I''ve heard it said that if you switch a number from signed to unsigned to "gain one bit" in magnitude, you should seriously think about just bumping it up to the next largest storage type; it''s an indication that you''re close to overflowing and have under-estimated the size of that spot. Choosing unsigned often has unpleasant effects as far as conversion of pointers, etc., so unless it''s absolutely necessary (e.g. sign extension when shifting), you''re probably best of leaving everything its default, which is signed.

(BTW, this last paragraph of advice comes from Lakos''s "Large-Scale C++ Design"; I''m a little more than half-bought-into this argument, but not 100%, so take it with a grain of salt).

quote:Original post by DerekSaw
Just search for 2''s complement... then you should know.

Way ahead of you, dude.