标准库标头 <cstdint> (C++11)

来自cppreference.com


 
C++
 
标准库头
 

此标头原作为 <stdint.h> 存在于 C 标准库。

此头文件是类型支持库的一部分，提供定宽整数类型和部分 C 数值极限接口。

类型

int8_tint16_tint32_tint64_tintN_t
(可选)(可选)(可选)(可选)(可选)
 宽度正好是 N（典型情况有 8、16、32 和 64）位且无填充位的有符号整数类型
(typedef) [编辑]
int_fast8_tint_fast16_tint_fast32_tint_fast64_tint_fastN_t
(可选)
 宽度至少有 N（典型情况有 8、16、32 和 64）位的最快的有符号整数类型
(typedef) [编辑]
int_least8_tint_least16_tint_least32_tint_least64_tint_leastN_t
(可选)
 宽度至少有 N（典型情况有 8、16、32 和 64）位的最小的有符号整数类型
（如果有定义 std::intN_t，那么 std::int_leastN_t 表示相同的类型）
(typedef) [编辑]
intmax_t
 最大宽度的有符号整数类型
(typedef) [编辑]
intptr_t
(可选)
 足以保有指向 void 的指针的有符号整数类型
(typedef) [编辑]
uint8_tuint16_tuint32_tuint64_tuintN_t
(可选)(可选)(可选)(可选)(可选)
 宽度正好是 N（典型情况有 8、16、32 和 64）位且无填充位的无符号整数类型
(typedef) [编辑]
uint_fast8_tuint_fast16_tuint_fast32_tuint_fast64_tuint_fastN_t
(可选)
 宽度至少有 N（典型情况有 8、16、32 和 64）位的最快的无符号整数类型
(typedef) [编辑]
uint_least8_tuint_least16_tuint_least32_tuint_least64_tuint_leastN_t
(可选)
 宽度至少有 N（典型情况有 8、16、32 和 64）位的最小的无符号整数类型
（如果有定义 std::uintN_t，那么 std::uint_leastN_t 表示相同的类型）
(typedef) [编辑]
uintmax_t
 最大宽度的无符号整数类型
(typedef) [编辑]
uintptr_t
(可选)
 足以保有指向 void 的指针的无符号整数类型
(typedef) [编辑]

宏

有符号整数：位宽
INTN_WIDTH
(C++26)(有条件提供)
 std::intN_t 的位宽（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INT_FASTN_WIDTH
(C++26)(有条件提供)
 std::int_fastN_t 的位宽（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INT_LEASTN_WIDTH
(C++26)(有条件提供)
 std::int_leastN_t 的位宽（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INTMAX_WIDTH
(C++26)
 std::intmax_t 的位宽
(宏常量) [编辑]
INTPTR_WIDTH
(C++26)(有条件提供)
 std::intptr_t 的位宽
(宏常量) [编辑]
有符号整数：最小值
INTN_MIN
(有条件提供)
 std::intN_t 的最小值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INT_FASTN_MIN
(有条件提供)
 std::int_fastN_t 的最小值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INT_LEASTN_MIN
(有条件提供)
 std::int_leastN_t 的最小值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INTPTR_MIN
(有条件提供)
 std::intptr_t 的最小值
(宏常量) [编辑]
INTMAX_MIN
 std::intmax_t 的最小值
(宏常量) [编辑]
有符号整数：最大值
INTN_MAX
(有条件提供)
 std::intN_t 的最大值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INT_FASTN_MAX
(有条件提供)
 std::int_fastN_t 的最大值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INT_LEASTN_MAX
(有条件提供)
 std::int_leastN_t 的最大值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
INTPTR_MAX
(有条件提供)
 std::intptr_t 的最大值
(宏常量) [编辑]
INTMAX_MAX
 std::intmax_t 的最大值
(宏常量) [编辑]
无符号整数：位宽
UINTN_WIDTH
(C++26)(有条件提供)
 std::uintN_t 的位宽（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
UINT_FASTN_WIDTH
(C++26)(有条件提供)
 std::uint_fastN_t 的位宽（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
UINT_LEASTN_WIDTH
(C++26)(有条件提供)
 std::uint_leastN_t 的位宽（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
UINTMAX_WIDTH
(C++26)
 std::uintmax_t 的位宽
(宏常量) [编辑]
UINTPTR_WIDTH
(C++26)(有条件提供)
 std::uintptr_t 的位宽
(宏常量) [编辑]
无符号整数：最大值
UINTN_MAX
(有条件提供)
 std::uintN_t 的最大值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
UINT_FASTN_MAX
(有条件提供)
 std::uint_fastN_t 的最大值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
UINT_LEASTN_MAX
(有条件提供)
 std::uint_leastN_t 的最大值（N 的典型情况有 8、16、32 和 64）
(宏常量) [编辑]
UINTPTR_MAX
(有条件提供)
 std::uintptr_t 的最大值
(宏常量) [编辑]
UINTMAX_MAX
 std::uintmax_t 的最大值
(宏常量) [编辑]
其他整数类型特征
PTRDIFF_WIDTH
(C++26)
 std::ptrdiff_t 的位宽
(宏常量) [编辑]
PTRDIFF_MIN
 std::ptrdiff_t 的最小值
(宏常量) [编辑]
PTRDIFF_MAX
 std::ptrdiff_t 的最大值
(宏常量) [编辑]
SIZE_WIDTH
(C++26)
 std::size_t 的位宽
(宏常量) [编辑]
SIZE_MAX
 std::size_t 的最大值
(宏常量) [编辑]
SIG_ATOMIC_WIDTH
(C++26)
 std::sig_atomic_t 的位宽
(宏常量) [编辑]
SIG_ATOMIC_MIN
 std::sig_atomic_t 的最小值
(宏常量) [编辑]
SIG_ATOMIC_MAX
 std::sig_atomic_t 的最大值
(宏常量) [编辑]
WINT_WIDTH
(C++26)
 std::wint_t 的位宽
(宏常量) [编辑]
WINT_MIN
 std::wint_t 的最小值
(宏常量) [编辑]
WINT_MAX
 std::wint_t 的最大值
(宏常量) [编辑]
WCHAR_WIDTH
(C++26)
 wchar_t 的位宽
(宏常量) [编辑]
WCHAR_MIN
 wchar_t 的最小值
(宏常量) [编辑]
WCHAR_MAX
 wchar_t 的最大值
(宏常量) [编辑]
整数常量的函数宏
INTN_C
(有条件提供)
 展开成 std::int_leastN_t 类型的整数常量表达式，它的值由实参指定
(宏函数) [编辑]
INTMAX_C
 展开成 std::intmax_t 类型的整数常量表达式，它的值由实参指定
(宏函数) [编辑]
UINTN_C
(有条件提供)
 展开成 std::uint_leastN_t 类型的整数常量表达式，它的值由实参指定
(宏函数) [编辑]
UINTMAX_C
 展开成 std::uintmax_t 类型的整数常量表达式，它的值由实参指定
(宏函数) [编辑]

注解

对于上面列出的每个标记有 (可选) 的 typedef 名，当且仅当实现提供了对应的某个类型时，实现才会定义该 typedef 名。

对于上面列出的每个标记有 (有条件提供) 的宏，当且仅当实现定义了对应的 typedef 名时，实现才会定义该宏。

概要

// 全部独立
#define __STDC_VERSION_STDINT_H__ 202311L

namespace std {
  using int8_t = /* 由实现定义 */;                  // 可选
  using int16_t = /* 由实现定义 */;                 // 可选
  using int32_t = /* 由实现定义 */;                 // 可选
  using int64_t = /* 由实现定义 */;                 // 可选
  using int/*N*/_t = /* 见描述 */;                  // 可选

  using int_fast8_t = /* 由实现定义 */;
  using int_fast16_t = /* 由实现定义 */;
  using int_fast32_t = /* 由实现定义 */;
  using int_fast64_t = /* 由实现定义 */;
  using int_fast/*N*/_t = /* 见描述 */;             // 可选

  using int_least8_t = /* 由实现定义 */;
  using int_least16_t = /* 由实现定义 */;
  using int_least32_t = /* 由实现定义 */;
  using int_least64_t = /* 由实现定义 */;
  using int_least/*N*/_t = /* 见描述 */;            // 可选

  using intmax_t = /* 由实现定义 */;
  using intptr_t = /* 由实现定义 */;                // 可选

  using uint8_t = /* 由实现定义 */;                 // 可选
  using uint16_t = /* 由实现定义 */;                // 可选
  using uint32_t = /* 由实现定义 */;                // 可选
  using uint64_t = /* 由实现定义 */;                // 可选
  using uint/*N*/_t = /* 见描述 */;                 // 可选

  using uint_fast8_t = /* 由实现定义 */;
  using uint_fast16_t = /* 由实现定义 */;
  using uint_fast32_t = /* 由实现定义 */;
  using uint_fast64_t = /* 由实现定义 */;
  using uint_fast/*N*/_t = /* 见描述 */;            // 可选

  using uint_least8_t = /* 由实现定义 */;
  using uint_least16_t = /* 由实现定义 */;
  using uint_least32_t = /* 由实现定义 */;
  using uint_least64_t = /* 由实现定义 */;
  using uint_least/*N*/_t = /* 见描述 */;           // 可选

  using uintmax_t = /* 由实现定义 */;
  using uintptr_t = /* 由实现定义 */;               // 可选
}

#define INT/*N*/_MIN                               /* 见描述 */
#define INT/*N*/_MAX                               /* 见描述 */
#define UINT/*N*/_MAX                              /* 见描述 */
#define INT/*N*/_WIDTH                             /* 见描述 */
#define UINT/*N*/_WIDTH                            /* 见描述 */

#define INT_FAST/*N*/_MIN                          /* 见描述 */
#define INT_FAST/*N*/_MAX                          /* 见描述 */
#define UINT_FAST/*N*/_MAX                         /* 见描述 */
#define INT_FAST/*N*/_WIDTH                        /* 见描述 */
#define UINT_FAST/*N*/_WIDTH                       /* 见描述 */

#define INT_LEAST/*N*/_MIN                         /* 见描述 */
#define INT_LEAST/*N*/_MAX                         /* 见描述 */
#define UINT_LEAST/*N*/_MAX                        /* 见描述 */
#define INT_LEAST/*N*/_WIDTH                       /* 见描述 */
#define UINT_LEAST/*N*/_WIDTH                      /* 见描述 */

#define INTMAX_MIN                                 /* 见描述 */
#define INTMAX_MAX                                 /* 见描述 */
#define UINTMAX_MAX                                /* 见描述 */
#define INTMAX_WIDTH                               /* 见描述 */
#define UINTMAX_WIDTH                              /* 见描述 */

#define INTPTR_MIN /* 见描述 */                     // 可选
#define INTPTR_MAX /* 见描述 */                     // 可选
#define UINTPTR_MAX /* 见描述 */                    // 可选
#define INTPTR_WIDTH /* 见描述 */                   // 可选
#define UINTPTR_WIDTH /* 见描述 */                  // 可选

#define PTRDIFF_MIN                                /* 见描述 */
#define PTRDIFF_MAX                                /* 见描述 */
#define PTRDIFF_WIDTH                              /* 见描述 */
#define SIZE_MAX                                   /* 见描述 */
#define SIZE_WIDTH                                 /* 见描述 */

#define SIG_ATOMIC_MIN                             /* 见描述 */
#define SIG_ATOMIC_MAX                             /* 见描述 */
#define SIG_ATOMIC_WIDTH                           /* 见描述 */

#define WCHAR_MIN                                  /* 见描述 */
#define WCHAR_MAX                                  /* 见描述 */
#define WCHAR_WIDTH                                /* 见描述 */

#define WINT_MIN                                   /* 见描述 */
#define WINT_MAX                                   /* 见描述 */
#define WINT_WIDTH                                 /* 见描述 */

#define INT/*N*/_C(value)                          /* 见描述 */
#define UINT/*N*/_C(value)                         /* 见描述 */
#define INTMAX_C(value)                            /* 见描述 */
#define UINTMAX_C(value)                           /* 见描述 */