stdint.h is a header file in the C standard library introduced in the C99 standard library section 7.18 to allow programmers to write more portable code by providing a set of typedefs that specify exact-width integer types, together with the defined minimum and maximum allowable values for each type, using macros^[1] . This header is particularly useful for embedded programming which often involves considerable manipulation of hardware specific I/O registers requiring integer data of fixed widths, specific locations and exact alignments. stdint.h (for C or C++), and cstdint (for C++) can be downloaded or quickly created if they are not provided.

The naming convention for exact-width integer types is intN_t for signed int and uintN_t for unsigned int ^[1] . For example int8_t and uint64_t amongst others could be declared together with defining their corresponding ranges INT8_MIN to INT8_MAX and 0 (zero) to UINT64_MAX; again using a similar but upper case naming convention. In addition stdint.h defines limits of integer types capable of holding object pointers such as UINTPTR_MAX, the value of which depends on the processor and its address range^[1].

The exact-width types and their corresponding ranges are only included in that header if they exist for that specific compiler/processor. Note that even on the same processor, two different compiler implementations can differ. The use of #if or #ifdef would allow the inclusion or exclusion of types by the use of compilers preprocessor so that the correct exact-width set is selected for a compiler and its processor target.

The related include file <limits.h> provides macros values for the range limits of common integer variable types. In C <limits.h> is already included in <stdint.h>, but in contrast to <stdint.h> which is implementation independent; all maximum and minimum integer values defined in <limits.h> are compiler implementation specific. For example a compiler generating 32 bit executables will define LONG_MIN as −2,147,483,648 [−2³¹] however for 64 bit processors targets, LONG_MIN can be −9,223,372,036,854,775,808 [−2⁶³].

Background

typedef signed T A;
typedef unsigned T B;

A a = 1;
B b = 1;
*(B*)&a = 0;
*(A*)&b = 0;

Integer types

The types <something>_t and u<something>_t are required to be corresponding signed and unsigned integer types. For the types that are marked optional, an implementation must either define both <something>_t and u<something>_t or neither of the two. The limits of these types shall be defined with macros with a similar name in the same fashion as described below.

If a type is of the form [u]<something>N_t (or similarly for a preprocessor define), N must be a positive decimal integer with no leading 0's.

Other integer limits

• PTRDIFF_MIN is the minimum value of ptrdiff_t.
• PTRDIFF_MAX is the maximum value of ptrdiff_t.
• SIZE_MAX is the maximum value (2¹⁶ − 1 or greater) of size_t.
• WCHAR_MIN is the minimum value of wchar_t.
• WCHAR_MAX is the maximum value of wchar_t.
• WINT_MIN is the minimum value of wint_t.
• WINT_MAX is the maximum value of wint_t.
• SIG_ATOMIC_MIN is the minimum value of sig_atomic_t.
• SIG_ATOMIC_MAX is the maximum value of sig_atomic_t.

Criticisms and caveats

• Some (non-conforming) implementations tack C99 support on top of a C89 runtime library.^{[citation needed]} One of the consequences of this is that the new printf and scanf specifiers aren't recognized and will probably lead to something undefined. The typical ways of working around this are:
  • The most common (and the most wrong) way is to use the long or unsigned long types as an intermediate step and pass these types into printf or scanf. This works reasonably well for the exact, minimum, and fast integer types less than 32-bits but may cause trouble with ptrdiff_t and size_t and the types larger than 32-bits, typically on platforms that use 32-bit longs and 64-bit pointers.
  • Not using scanf directly but manually reading in a buffer, calling strto[i|u]max, and then converting it to the desired type. This doesn't help with printing out integers though.
  • Using a 3rd-party printf and scanf library that is C99 compatible.
  • Using the C99 standard printing format specifiers. PRId64 for example. These are declared in inttypes.h.

• The rules for integer rank and corresponding integer types may force implementers to choose the lesser of two evils in not supporting an integer type, making a bad compromise, or supporting an integer type a non-conforming way.
  • For example, there are machines that either have special support for an extremely large signed integer register or an extremely large unsigned integer register without supporting the other type.^{[citation needed]} An implementation can either choose not to expose this to a C implementation, synthesize a slow type as the corresponding integer type, synthesizing a weird corresponding integer type, or expose the integer to the programmer without setting it to the [u]intmax_t types or synthesizing a corresponding integer type.

• The [u]intN_t types are a compromise between the desire to have guaranteed two's complement integer types and the desire to have guaranteed types with no padding bits (as opposed to a more fine grained approach which would define more types). Because of the "all or nothing" approach to the [u]intN_t types, an implementation might have to play the same sort of games described above depending on whether they care about speed, programmer convenience, or standards conformance.

See also

• inttypes.h

Notes and references

1. 1 2 3 4 5 6 7 8 technically, it actually allows 0 or more value bits, but the only way you can construct this is with a single-bit bit-field of a signed integer
2. ↑ http://www.tuxgraphics.org/common/src2/article09043/avr-libc-user-manual-1.6.4/group__avr__stdint.html
3. ↑ http://linux.die.net/man/3/intptr_t

• stdint.h: integer types – Base Definitions Reference, The Single UNIX® Specification, Issue 7 from The Open Group

External links

• C++ reference for fixed width integer types inherited from C

As stdint.h is not shipped with older C++ compilers and Visual Studio C++ products prior to Visual Studio 2010, third-party implementations are available:

• pstdint.h – A cross-platform, free implementation from Paul Hsieh. This implementation was tested on the following compilers, all with 0 warnings at their highest respective settings: Borland Turbo C 2.0, WATCOM C/C++ 11.0 (16 bits and 32bits), Microsoft Visual C++ 6.0 (32 bit), Microsoft Visual Studio.net (VC7), Intel C++ 4.0, GNU gcc v3.3.3.
• msinttypes – ISO C9x compliant stdint.h and inttypes.h for Microsoft Visual Studio are available on Google Code. This implementation was tested with Microsoft Visual Studio 6.0, Microsoft Visual Studio .NET 2003, Microsoft Visual Studio 2005, and Microsoft Visual Studio 2008.
• boost/cstdint.hpp – This file from the Boost library contains data types which are in stdint.h. The advantage of the use of <boost/cstdint.hpp> is that it can be used on many platforms. The code becomes naturally portable, and can be compiled on any platform without changes whenever the boost library can be used.