What affects the range of a specific data type in C language?

It happens that the rank of a inton some platforms is really that: -32768a 32767(16-bit platforms). But on 32-bit platforms, the intis bigger. You are probably on a modern platform (32 or 64 bit) so you intcan host a much larger range.

With this code you can know the size of a intin your platform:

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

int main(int argc, char **argv)
{
  printf("Tamaño del int: %d\n", sizeof(int));
  printf("INT_MAX: %d\n", INT_MAX);
  return 0;
}

Well, integral types in C and most languages ​​have something called limits , you can find a header in your C compiler called limits.hwhere all the limits are on your current platform.

The subject with the limits, is the following:

A intis 32 bytes, right? A long longis 64 bytes.

Taking this to the hexadecimal system you can have the following values:

FF FF FF FF <- Int
FF FF FF FF FF FF FF FF <- Long long.

So, you have from 00 00 00 00 00 00 00 00to FF FF FF FF FF FF FF FFin values ​​for a long integer (long long).

But! It happens that when it comes to making the subject of signs in integral types...

When a number has a sign, you only have half of its real range of values ​​available, since certain standards are used to represent the sign, for example the following program:

int main(void) {
    int test = 0xFFFFFFF0;
    printf("%d - %u\n", test, (unsigned int)test);
}

It will give you as a result:

-16 - 4294967280

And if you try to invert the bytes:

int main(void) {
    int test = 0x0000000f;
    printf("%d - %u\n", test, (unsigned int)test);
}

You will get the following result:

15 - 15

With all this, the size of some types (in bytes), this data can vary depending on the platform:

- char      : 1   <- Este es de tipo integral.
- short     : 2
- int       : 4
- float     : 4
- long      : 8 (64 bits)
- long long : 8
- double    : 8

Below is a program that demonstrates it.

int main(void) {
    printf("sizeof(char)      == %d\n"
           "sizeof(short)     == %d\n"
           "sizeof(int)       == %d\n"
           "sizeof(float)     == %d\n"
           "sizeof(long)      == %d\n"
           "sizeof(long long) == %d\n"
           "sizeof(double)    == %d\n",
           sizeof(char), sizeof(short), sizeof(int),
           sizeof(long), sizeof(float), sizeof(long long), sizeof(double)
          );
}

As an additional reference, to know the current limits of a given type you can use the limits.h library (another C++ link ):

#include <limits.h>

int main()
{
  printf("Rango para int (%d,%d)\n",INT_MIN,INT_MAX);
  printf("Rango para unsigned int (%u,%u)\n",UINT_MIN,UINT_MAX);
}