Determine the ranges of char by direct computation in C89 (do not use limits.h)

Question

I am trying to solve the Ex 2-1 of K&R's C book. The exercise asks to, among others, determine the ranges of char by direct computation (rather than printing the values directly from the limits.h). Any idea on how this should be done nicely?

Answer 1

Ok, I throw my version in the ring:

unsigned char uchar_max = (unsigned char)~0;
// min is 0, of course

signed char schar_min = (signed char)(uchar_max & ~(uchar_max >> 1));
signed char schar_max = (signed char)(0 - (schar_min + 1));

It does assume 2's complement for signed and the same size for signed and unsigned char. While the former I just define, the latter I'm sure can be deduced from the standard as both are char and have to hold all encodings of the "execution charset" (What would that imply for RL-encoded charsets like UTF-8).

It is straigt-forward to get a 1's complement and sing/magnitude-version from this. Note that the unsigned version is always the same.

One advantage is that is completely runs with char types and no loops, etc. So it will be still performant on 8-bit architectures.

Hmm ... I really thought this would need a loop for signed. What did I miss?

Answer 2

Assuming that the type will wrap intelligently¹, you can simply start by setting the char variable to be zero.

Then increment it until the new value is less than the previous value.

The new value is the minimum, the previous value was the maximum.

The following code should be a good start:

#include<stdio.h>
int main (void) {
    char prev = 0, c = 0;
    while (c >= prev) {
        prev = c;
        c++;
    }
    printf ("Minimum is %d\n", c);
    printf ("Maximum is %d\n", prev);
    return 0;
}

---

¹ Technically, overflowing a variable is undefined behaviour and anything can happen, but the vast majority of implementations will work. Just keep in mind it's not guaranteed to work.

In fact, the difficulty in working this out in a portable way (some implementations had various different bit-widths for char and some even used different encoding schemes for negative numbers) is probably precisely why those useful macros were put into limits.h in the first place.

Answer 3

You could always try the ol' standby, printf...

let's just strip things down for simplicity's sake.

This isn't a complete answer to your question, but it will check to see if a char is 8-bit--with a little help (yes, there's a bug in the code). I'll leave it up to you to figure out how.

#include <stdio.h>

#DEFINE MMAX_8_BIT_SIGNED_CHAR 127

main ()
{
    char c;

   c = MAX_8_BIT_SIGNED_CHAR;

   printf("%d\n", c);
   c++;
  printf("%d\n", c);
}

Look at the output. I'm not going to give you the rest of the answer because I think you will get more out of it if you figure it out yourself, but I will say that you might want to take a look at the bit shift operator.

Answer 4

There are 3 relatively simple functions that can cover both the signed and unsigned types on both x86 & x86_64:

/* signed data type low storage limit */
long long limit_s_low (unsigned char bytes)
{   return -(1ULL << (bytes * CHAR_BIT - 1)); }

/* signed data type high storage limit */
long long limit_s_high (unsigned char bytes)
{   return (1ULL << (bytes * CHAR_BIT - 1)) - 1; }

/* unsigned data type high storage limit */
unsigned long long limit_u_high (unsigned char bytes)
{
    if (bytes < sizeof (long long))
        return (1ULL << (bytes * CHAR_BIT)) - 1;
    else
        return ~1ULL - 1;
}

With CHAR_BIT generally being 8.

Answer 5

• the smart way, simply calculate sizeof() of your variable and you know it's that many times larger than whatever has sizeof()=1, usually char. Given that you can use math to calculate the range. Doesn't work if you have odd sized types, like 3 bit chars or something.

• the try hard way, put 0 in the type, and increment until it doesn't increment anymore (wrap around or stays the same depending on machine). Whatever the number before that was, that's the max. Do the same for min.