Check whether variable of unknown signedness is in interval

Question

In some C99 code, I need to check whether variable i is in the interval [0, max] where max is known to be positive. The problem is that the type of the variable is allowed to be both signed and unsigned (by changing a typedef). How does one best check that the variable is in the interval?

The straightforward approach would be:

bool is_in_interval(my_type i, my_type max) {
    assert(max > 0);
    return (i >= 0 && i <= max);
}

This will work fine when we have typedef int my_type;. But when my_type is unsigned (i.e., typedef unsigned int my_type;), i >= 0 is always true and compilers will (rightly) warn for it, which I want to avoid. (I don't want to turn off that warning since it's useful when such comparisons actually are unintended, and just ignoring compiler warnings is not a good idea.)

My current idea is to cast i to an unsigned type and just check the upper bound:

bool is_in_interval(my_type i, my_type max) {
    assert(max > 0);
    return ((size_t) i <= (size_t) max);
}

If the signed type has a two's complement representation, any negative value should be greater than max once cast to the unsigned version, right? If so, this should work. I'm, however, uncertain whether this is an advisable approach. Is it, for example, safe to assume that signed types use two's complement on all platforms? Is there some better way to do this?

Answer 1

Check against 0 and max. Yet avoid a direct >= 0 test.

Casting is a problem as it may narrow the value in some implementation defined way.

bool is_in_interval(my_type i, my_type max) {
  // first, take care of the easy case
  if (i > max) return false;
  if (i > 0) return true;
  return i == 0;
}

---

I will ponder this some more too.

Answer 2

I think this should shut the compiler up:

bool is_in_interval(my_type i, my_type max) {
  my_type zero = 0;
  assert(max > 0);
  return (zero <= i && i <= max);
}

Answer 3

Maybe this is another straightforward approach:

bool is_in_interval(my_type i, my_type max) {
    assert(max > 0);
    if ((my_type)-1 > 0)
        return (i <= max); // my_type is unsigned
    else
        return (0 <= i && i <= max); // my_type is signed
}

Answer 4

If your compiler supports it, I believe the cleanest solution would be to keep the code as is, but to use a #pragma directive to locally disable the spurious warning. For example, for GCC 4.6.4+, the following would do the trick:

bool is_in_interval(my_type i, my_type max) {
    assert(max > 0);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
    /* i >= 0 could warn if my_type is unsigned */
    return (i >= 0 && i <= max);
#pragma GCC diagnostic pop
}

Apparently, the exact same #pragmas should work for Clang too, since it imitates GCC's syntax. Other compilers may have similar syntax (e.g. #pragma warning( disable: ... ) for Visual C/C++), and it should be possible to use preprocessor directives to select the appropriate #pragmas for each compiler.

The main downside of this method is aesthetic — it litters the code with ugly #pragmas. That said, I would consider that preferable to deliberately obfuscating (and possibly de-optimizing) your code just to avoid a compiler warning. At least, with the #pragmas, it's clear to the next programmer that reads the code why it's written the way it is.

---

To make this cleaner and more portable, you can use the C99 _Pragma() operator to define macros that disable and re-enable the warnings, e.g. like this:

#if __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ >= 40604
#  define NO_TYPE_LIMIT_WARNINGS \
       _Pragma("GCC diagnostic push") \
       _Pragma("GCC diagnostic ignored \"-Wtype-limits\"")
#  define RESTORE_WARNINGS \
       _Pragma("GCC diagnostic pop")
/* Add checks for other compilers here! */
#else
#  define NO_TYPE_LIMIT_WARNINGS /* nothing */
#  define RESTORE_WARNINGS /* nothing */
#endif

and use them like this:

bool is_in_interval(my_type i, my_type max) {
    assert(max > 0);
    NO_TYPE_LIMIT_WARNINGS; /* i >= 0 could warn if my_type is unsigned */
    return (i >= 0 && i <= max);
    RESTORE_WARNINGS;
}

Alternatively, if you wanted to support pre-C99 compilers, you could create a pair of header files (without any include guards!) named something like warnings_off.h and warnings_restore.h that contain the appropriate #pragma for each compiler, and then bracket the code you want to silence warnings for with:

#include "warnings_off.h"
/* ...code that emits spurious warnings here... */
#include "warnings_restore.h"

Answer 5

A simple solution is to do a 2-sided test.

The only attribute really lost is modest efficiency/performance. No other problems.

Although OP has certainly considered this, any solution should be weighed against this as a reference.

bool is_in_interval2(my_type i, my_type min, my_type max) {
  return i >= min && i <= max;
}

// Could make this a macro or inline
bool is_in_interval(my_type i, my_type max) {
  return is_in_interval2(i, 0, max);
}