views:

178

answers:

3

In limits.h, there are #defines for INT_MAX and INT_MIN (and SHRT_* and LONG_* and so on), but only UINT_MAX.

Should I define UINT_MIN myself? Is 0 (positive zero) a portable value?

+17  A: 

It's an unsigned integer - by definition its smallest possible value is 0. If you want some justification besides just common sense, the standard says:

6.2.6.2 Integer types

  1. For unsigned integer types other than unsigned char, the bits of the object representation shall be divided into two groups: value bits and padding bits (there need not be any of the latter). If there are N value bits, each bit shall represent a different power of 2 between 1 and 2^(N−1), so that objects of that type shall be capable of representing values from 0 to 2^(N−1) using a pure binary representation; this shall be known as the value representation. The values of any padding bits are unspecified.
Carl Norum
love the standard. especially when it's quoted.
Matt Joiner
This does not answer my question.
Ariel Bold
@Ariel, how does it not answer your question? The minimum value for an unsigned type is defined by the standard to be 0.
Carl Norum
+6  A: 

You could use std::numeric_limits<unsigned int>::min().

Kirill V. Lyadvinsky
This won't work in C/C++.
Ariel Bold
This will work in C++, and this will not work in C. What is C/C++?
Kirill V. Lyadvinsky
Our source tree contains C and C++ and so this need to work with both. This is why I tagged the question with both.
Ariel Bold
+1  A: 

If you want to be "typesafe" you could use 0U, so if you use it in an expression you will have the correct promotions to unsigned.

Jens Gustedt
So I should `#define UINT_MIN +0U` in `limits.h`?
Ariel Bold
Thinking of it, it is perhaps not so a good idea to have a file that has the same name as a standard file or to mess around with the later. I'd put it another place. If you want to have a `+` to the `0U` (why?) you should have the whole in parenthesis `(+0U)` since otherwise you might have unwanted effects when the `+` could be interpreted as addition.
Jens Gustedt
You don't need parenthesis. Even in `1+UINT_MIN`, it would expand to `1+ +0U`, which is a correct expression. Macro expansion happens at token level, and will not glue the two plusses together.
MSalters
@MSalters: I think you need it since it makes invalid sequences valid. Something like `5 UINT_MIN` would become valid, where it really shouldn't.
Jens Gustedt
@Jens: Using that logic, I can equally say that you must _not_ have parenthesis as it makes invalid sequences valid. Something like `sin UINT_MIN` becomes valid.
MSalters
@MSalters: good point. So it is a matter of taste which invalid sequences should become valid ;-) Brings us back to the question, why using the `+` in the first place? `0U` would be much simpler, then, and is really a well defined constant.
Jens Gustedt