Fixed width integer types (since C++11)

Types

The implementation may define typedef names int N _t , int_fast N _t , int_least N _t , uint N _t , uint_fast N _t , and uint_least N _t when N is not 8, 16, 32 or 64. Typedef names of the form int N _t may only be defined if the implementation supports an integer type of that width with no padding. Thus, std::uint24_t denotes an unsigned integer type with a width of exactly 24 bits.

Each of the macros listed in below is defined if and only if the implementation defines the corresponding typedef name. The macros INT N _C and UINT N _C correspond to the typedef names int_least N _t and uint_least N _t , respectively.

Macro constants

Function macros for minimum-width integer constants

#include <cstdint>
UINT64_C(0x123) // expands to a literal of type uint_least64_t and value 0x123

Format macro constants

Format constants for the std::fprintf family of functions

Each of the PRI macros listed here is defined if and only if the implementation defines the corresponding typedef name.

Format constants for the std::fscanf family of functions

Each of the SCN macros listed in here is defined if and only if the implementation defines the corresponding typedef name and has a suitable std::fscanf length modifier for the type.

Notes

Because C++ interprets a character immediately following a string literal as a user-defined string literal , C code such as printf ( "%" PRId64 " \n " ,n ) ; is invalid C++ and requires a space before PRId64 .

The C99 standard suggests that C++ implementations should not define the above limit, constant, or format macros unless the macros __STDC_LIMIT_MACROS , __STDC_CONSTANT_MACROS or __STDC_FORMAT_MACROS (respectively) are defined before including the relevant C header ( stdint.h or inttypes.h ). This recommendation was not adopted by any C++ standard and was removed in C11. However, some implementations (such as glibc 2.17) try to apply this rule, and it may be necessary to define the __STDC macros; C++ compilers may try to work around this by automatically defining them in some circumstances.

std::int8_t may be signed char and std::uint8_t may be unsigned char , but neither can be char regardless of its signedness (because char is not considered a "signed integer type" or "unsigned integer type").

Example

#include <cinttypes>
#include <cstdio>
 
int main()
{
    std::printf("%zu\n", sizeof(std::int64_t));
    std::printf("%s\n", PRId64);
    std::printf("%+" PRId64 "\n", INT64_MIN);
    std::printf("%+" PRId64 "\n", INT64_MAX);
 
    std::int64_t n = 7;
    std::printf("%+" PRId64 "\n", n);
}

8
lld
-9223372036854775808
+9223372036854775807
+7

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

References

See also

• Fundamental types