[ C preprocessor define for value of a given type where every byte is 0xFF? ]

Let's say there's a data type defined as such:

typedef int my_integer_type;

Somewhere else, there exists code like this

#define MAX_MY_INTEGER_TYPE 0xFFFFFFFF

However, if my_integer_type later is changed to 8 bytes instead of 4, MAX_MY_INTEGER_TYPE will need to be updated as well. Is there a way for MAX_MY_INTEGER_TYPE to be a bit smarter, to basically represent the number of bytes in my_integer_type all set to 0xFF?

I realize there are other traditional ways to get the maximum integer size (like here: maximum value of int), but my actual use case is a bit more complex and I cannot apply those solutions.

Answer 1

---

You can calculate the maximum size of an integer like using bit-wise operations.

For an unsigned integer you can do it like this:

const unsigned int MAX_SIZE = ~0;

or, you can do it like this if your compiler does not complain:

const unsigned int MAX_SIZE = -1;

EDIT

For your particular case, it seems you want to be able to calculate the maximum value of a signed type. Assuming the sign is calculated using 2's complement (as is in most systems), you can use this methods:

const my_integer_type MAX_MY_INTEGER_TYPE =
   ~((my_integer_type)1 << (sizeof(my_integer_type) * CHAR_BIT) - 1);

So, what I do here is calculate the size of the type. Whatever the size is, I'm going to subtract 1 from that. I use the resulting number to shift a 1 to the left most position. Then I invert the whole thing.

Let's say that my_integer_type is 1 bytes. That is 8 bits, meaning that the shift amount is 7. I take the 1 and shift it. The result of the shift looks like this: 0x80. When you invert it, you get this: 0x7f. And that is the maximum value (of course, assuming it uses 2's complement).

Note that I did not used the preprocessor. Unfortunately, the preprossor is a simple find and replace tool that is not aware of types in C. So, you'll have to use constants.

Answer 2

---

No, for signed integer types there is basically no way to calculate the maximum values for the type. This is the main reason why all the predefined MAX-macros such as INT_MAX exist. To avoid the maintenance problem you could go the other way round

#include <limits.h>

#define MY_INTEGER_TYPE_MAX 0xFFFF...FFF  // whatever number of 'F' you chose

#if MY_INTEGER_TYPE_MAX <= SCHAR_MAX
typedef signed char my_integer_type;
#elsif MY_INTEGER_TYPE_MAX <= SHRT_MAX
typedef signed short int my_integer_type;
#elsif MY_INTEGER_TYPE_MAX <= INT_MAX
typedef signed int my_integer_type;
#elsif MY_INTEGER_TYPE_MAX <= LONG_MAX
typedef signed long int my_integer_type;
#elsif MY_INTEGER_TYPE_MAX <= LLONG_MAX
typedef signed long long int my_integer_type;
#else
typedef intmax_t my_integer_type;
#endif

You see that it is not a very long list of cases that you have to differentiate.

Answer 3

---

Not clear is OP wants "every byte is 0xFF" or the maximum integer value.

1) [Edit] Assuming "every byte is 0xFF" is OP's goal, @Eric Postpischil idea is sound and simple

// Better name: MY_INTEGER_TYPE_ALL_BITS_SET
#define MAX_MY_INTEGER_TYPE (~ (my_integer_type) 0)

2) Interesting OP is asking for "value of a given type where every byte is 0xFF?" and then proceeds to call it "MAX_MY_INTEGER_TYPE". This does sound like an unsigned as the maximum signed value is rarely (if ever) "every byte is 0xFF". Using -1 as suggested by @H2CO3 looks good.

#define MAX_MY_INTEGER ((my_integer_type) 0 - 1).

3) Not yet answered: if OP wants max value and my_integer_type could be signed (and not assuming 2's complement).