Calculating the range of long in C

Question

I am writing a program in C to calculate the range of different data types. Please look at the following code:

#include <stdio.h>

main()
{
    int a;
    long b;

    for (a = 0; a <= 0; --a)
        ;
    ++a;
    printf("INT_MIN: %d\n", a);
    for (a = 0; a >= 0; ++a)
        ;
    --a;
    printf("INT_MAX: %d\n", a);
    for (b = 0; b <= 0; --b)
        ;
    ++b;
    printf("LONG_MIN: %d\n", b);
    for (b = 0; b >= 0; ++b)
        ;
    --b;
    printf("LONG_MAX: %d\n", b);
}

The output was:

INT_MIN: -32768
INT_MIN: 32767
LONG_MIN: 0
LONT_MAX: -1

The program took a long pause to print the long values. I also put a printf inside the third loop to test the program (not mentioned here). I found that b did not exit the loop even when it became positive.

I used the same method of calculation. Why did it work for int but not for long?

Answer 1

You are using the wrong format specifier. Since b is of type long, use

printf("LONG_MIN: %ld\n", b);

---

In fact, if you enabled all warnings, the compiler probably would warn you, e.g:

t.c:19:30: warning: format specifies type 'int' but the argument has type 'long' [-Wformat]
    printf("LONG_MIN: %d\n", b);

Answer 2

In C it is undefined behaviour to decrement a signed integer beyond its minimum value (and similiarly for incrementing above the maximum value). Your program could do literally anything.

For example, gcc compiles your program to an infinite loop with no output.

The proper approach is:

#include <limits.h>
#include <stdio.h>

int main()
{
    printf("INT_MIN = %d\n", INT_MIN);
    // etc.
}

Answer 3

In

printf("LONG_MIN: %d\n", b);

the format specifier is %d which works for integers(int). It should be changed to %ld to print long integers(long) and so is the case with

printf("LONG_MAX: %d\n", b);

These statements should be

printf("LONG_MIN: %ld\n", b);

&

printf("LONG_MAX: %ld\n", b);

This approach may not work for all compilers(eg gcc) and an easier approach would be to use limits.h.

Also check Integer Limits.

Answer 4

As already stated, the code you provided invokes undefined behavior. Thus it could calculate what you want or launch nuclear missiles ...

The reason for the undefined behavior is the signed integer overflow that you are provoking in order to "test" the range of the data types.

If you just want to know the range of int, long and friends, then limits.h is the place to look for. But if you really want ...

[..] to calculate the range [..]

... for what ever reason, then you could do so with the unsigned variant of the respective type (though see the note at the end), and calculate the maximum like so:

unsigned long calculate_max_ulong(void) {
  unsigned long follow = 0;
  unsigned long lead = 1;
  while (lead != 0) {
    ++lead;
    ++follow;
  }
  return follow;
}

This only results in an unsigned integer wrap (from the max value to 0), which is not classified as undefined behavior. With the result from above, you can get the minimum and maximum of the corresponding signed type like so:

assert(sizeof(long) == sizeof(unsigned long));
unsigned long umax_h = calculate_max_ulong() / 2u;
long max = umax_h;
long min = - max - 1;

(Ideone link)

Assuming two's complement for signed and that the unsigned type has only one value bit more than the signed type. See §6.2.6.2/2 (N1570, for example) for further information.