Thread: computing max/min values of numeric variables: ints, chars, etc

It's a part of an exercise in K&R;

Write a program to determine the ranges of char , short , int , and long variables, both signed and unsigned , by printing appropriate values from standard headers and by direct computation. Harder if you compute them: determine the ranges of the various floating-point types.

Thats why i was wandering if there are any other methods.

#include <limits.h>

Since the exercise is expecting computation then the increment method seems fine. It may take too long for larger integers though. Perhaps start with 1 and shift it left until the value is less than its previous value. That will determine the number of bits. Of course you could do sizeof(n)*8 assuming a byte is 8 bites on your architecture.

If it can not be assumed a machine has 8 bits per byte, and it can not be assumed the machine uses 2's complement representation, then incrementing until the result is not one greater than it was previous is one reliable way.

Some fancier iterative way that uses larger step sizes which are reduced logarithmically would be faster.

You can use CHAR_BITS * sizeof(whatever).

To be clear, BYTE_BITS would be more correct, but Bayint Naung has a good idea.

Is there an architecture still in use that uses not 8 bit bytes? I know the byte used to vary quite a bit, but I have no knowledge of a current machine using non-8 bit bytes.

What a mystery!

We went through this same question just six months ago. Why are you bringing up the same questions, again?

As discussed here:
direct computation

there are three ways to get the max and minimum values for data types:

1) Use sizeof(datatype) and remember to subtract one for positive values, if it's signed.

2) Have your compiler tell you what the values are, using macro's like INT_MAX or MAX_INT or whatever names your compiler uses for this. Your compiler's help files will pinpoint the exact name for these macros.

3) Direct computation, until you overflow. It's undefined in the C standard, but not necessarily on your computer and compiler. Remember that it relies on 2's complement, which the vast majority of modern PC's use, and on your compiler using 2's complement in a very popular manner.

EDIT: Adak beat me to it .
Or you could overflow the variable.

Code:

    int max;
    int test = 1;
    for(max = 0; test > max; test++)
        max = test;
    printf("Max Value: %i", max);
    printf("Min Value: %i", test);

"test" will overflow to the lowest possible, and "max" will equal the highest.

Originally Posted by grumpy

To be clear, Bayint had it right. CHAR_BITS is defined in the C standard. BYTE_BITS is not.

The results of overflowing or underflowing a signed integral type are undefined i.e. not guaranteed to work. Unsigned types wrap (or, more accurately, use modulo arithmetic) signed types don't.

An unsigned would overflow to 0, an unsigned's minimum value. You'd have to printf with "%u" instead "%i" though.

Code:

    unsigned int max;
    unsigned int test = 1;
    for(max = 0; test > max; test++)
        max = test;
    printf("Max Value: %u\n", max);
    printf("Min Value %u",test);

I get 4294967295 and 0 on 64 bit Linux.

As for CHAR_BIT and BYTE_BIT, that was ignorance on my part. I didn't know CHAR_BIT was already defined, I though Bayint was meaning OP had to fill in the value every time, in which case BYTE would make more sense. Bayint was right. sorry.