The _t data types are typedef types in the stdint.h header, while int is an in built fundamental data type. This make the _t available only if stdint.h exists. int on the other hand is guaranteed to exist.

At the time the C99 Standard was ratified, there already existed countless C programs that used int32 as an identifier. On platforms where both int and long were 32 bits, some of that pre-existing code would have defined int32 as int and some as long (the latter allows compatibility with platforms where int is 16 bits but long is 32; the former allows compatibility with platforms where int is 32 bits but long is 64). While it might have made sense for compilers to allow "int" and "long" to by synonymous on platforms where they're both 32 bits and have matching representations, in which case the "new" int32 type could compatible with both, the Standard doesn't allow for that.

Code written for a platform where int32 is known to be synonymous with int can use int* and int32* interchangeably. Code written for a platform where int32 is known to be synonymous with long can use int32* and long* interchangeably. Even on platforms where both int and long have identical representations, however, the Standard requires platforms squawk if an attempt is made to convert an int* to long* or vice versa without a cast.

Further, even on platforms where int and long have the same representation, casting an int* to a long* is not required to yield a pointer that's usable as a long*; the current maintainers of gcc believe that since the Standard doesn't require that such a cast work, their compiler should generate code where such casts sometimes fail.

Thus, if C99 had used int32 rather than int32_t, it would have had to break code that defines that identifier as int and expects it to be synonymous with int, or code that defines that defines that identifier as long and expects it to be synonymous with long.

1. Firstly, why do we need int32_t as we already have different variation for it like short int unsigned int and etc.

Because short int, unsigned int, etc aren't portable among architectures.

If you mean exactly 32 bits, just say that explicitely. Otherwise you might end up using 64 bits just using the unsigned int with a different CPU architecture.

2. Secondly does the use of this type of fixed size types makes programs portable?

Yes, as mentioned above.

Those integer types are all defined in stdint.h

2147483647

Here's what you need to remember:

• It's 2 billion.
• The next three triplets are increasing like so: 100s, 400s, 600s
• The first and the last triplet need 3 added to them so they get rounded up to 50 (eg 147 + 3 = 150 & 647 + 3 = 650)
• The second triplet needs 3 subtracted from it to round it down to 80 (eg 483 - 3 = 480)

Hence 2, 147, 483, 647

C doesn't concern itself very much with exact sizes of integer types, C99 introduces the header stdint.h , which is probably your best bet. Include that and you can use e.g. int32_t. Of course not all platforms might support that.

"is always 32-bit on most platforms" - what's wrong with that snippet? :-)

The C standard does not mandate the sizes of many of its integral types. It does mandate relative sizes, for example, sizeof(int) >= sizeof(short) and so on. It also mandates minimum ranges but allows for multiple encoding schemes (two's complement, ones' complement, and sign/magnitude).

If you want a specific sized variable, you need to use one suitable for the platform you're running on, such as the use of #ifdef's, something like:

#ifdef LONG_IS_32BITS
    typedef long int32;
#else
    #ifdef INT_IS_32BITS
        typedef int int32;
    #else
        #error No 32-bit data type available
    #endif
#endif

Alternatively, C99 and above allows for exact width integer types intN_t and uintN_t:

1. The typedef name intN_t designates a signed integer type with width N, no padding bits, and a two's complement representation. Thus, int8_t denotes a signed integer type with a width of exactly 8 bits.
2. The typedef name uintN_t designates an unsigned integer type with width N. Thus, uint24_t denotes an unsigned integer type with a width of exactly 24 bits.
3. These types are optional. However, if an implementation provides integer types with widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a two's complement representation, it shall define the corresponding typedef names.