The include file <inttypes.h> was added to the Solaris 2.6 release to provide constants, macros, and derived types that help programmers make their code compatible with explicitly sized data items, independent of the compilation environment. It contains mechanisms for manipulating 8-bit, 16-bit, 32-bit, and 64-bit objects. The file is part of an ANSI C proposal and tracks the ISO/JTC1/SC22/WG14 C committee's working draft for the revision of the current ISO C standard, ISO/IEC 9899:1990 Programming Language – C.
The basic features provided by <inttypes.h> are:
A set of fixed-width integer types
uintptr_t and other helpful types
Format string macros
These are discussed in more detail in the sections that follow.
The fixed-width integer types provided by <inttypes.h> include
both signed and unsigned integer types, such as
uint64_t. Derived types defined
as the smallest integer types that can hold the specified number of bits include
These fixed-width types should not be used indiscriminately.
int can continue to be used for such things as loop counters
and file descriptors, and
long can be used for array indices. On the
other hand, you should use fixed-width types for explicit binary representations of:
Binary interface specifications (that have explicitly sized objects or involve sharing or communication between 32–bit and 64–bit programs)
Binary data structures (that are used by 32–bit and 64–bit programs through shared memory, files, and so on)
uintptr_tand Other Helpful Types
Other useful types provided by <inttypes.h> include signed
and unsigned integer types large enough to hold a pointer. These are given as
uintptr_t. In addition,
uintmax_t are defined to be the longest (in bits) signed and unsigned integer
uintptr_t type as the integral type for pointers is a
better option than using a fundamental type such as
unsigned long. Even
unsigned long is the same size as a pointer in both the ILP32
and LP64 data models, the use of the
uintptr_t requires only the definition
uintptr_t to change when a different data model is used. This makes
it portable to many other systems. It is also a clearer way to express your intentions
uintptr_t types are extremely useful
for casting pointers when you want to do address arithmetic. They should be used instead
unsigned long for this purpose.
uintptr_t for casting is usually safer than
intptr_t, especially for comparisons.
Macros are provided to specify the size and sign of a given constant. The macros are INT8_C(c), ..., INT64_C(c), UINT8_C(c),..., UINT64_C(c). Basically, these macros place an l, ul, ll, or ull at the end of the constant, if necessary. For example, INT64_C(1) appends ll to the constant 1 for ILP32 and an l for LP64.
Macros for making a constant the biggest type are INTMAX_C(c) and UINTMAX_C(c). These macros can be very useful for specifying the type of constants described in Guidelines for Converting to LP64.
The limits defined by <inttypes.h> are constants specifying
the minimum and maximum values of various integer types. This includes minimum and
maximum values of each of the fixed-width types, such as
INT64_MAX, and their unsigned
The minimum and maximum for each of the least-sized types are given, too. These
INT_LEAST64_MAX, and their unsigned counterparts.
Finally, the minimum and maximum value of the largest supported integer types
are defined. These include
their corresponding unsigned versions.
Macros for specifying the printf and scanf format
specifiers are also provided in <inttypes.h> . Essentially,
these macros prepend the format specifier with an l or ll to specify the argument as a
given the number of bits in the argument, which is built into the name of the macro.
Macros for printf(3C) format specifiers exist for printing 8-bit, 16-bit, 32-bit, and 64-bit integers, the smallest integer types, and the biggest integer types, in decimal, octal, unsigned, and hexadecimal. For example, printing a 64–bit integer in hexadecimal notation:
int64_t i; printf("i =%" PRIx64 "\n", i);
Similarly, there are macros for scanf(3C) format specifiers for reading 8-bit, 16-bit, 32-bit, and 64-bit integers and the biggest integer type in decimal, octal, unsigned, and hexadecimal. For example, reading an unsigned 64–bit decimal integer:
uint64_t u; scanf("%" SCNu64 "\n", &u);
Do not use these macros indiscriminately. They are best used in conjunction with the fixed-width types. Refer to the section Fixed-Width Integer Types for more details.