C++标准模板（STL）- 类型支持 (数值极限，C 数值极限接口）

C 数值极限接口

参阅 std::numeric_limits 接口

定义于头文件
PTRDIFF_MIN (C++11)	std::ptrdiff_t 类型对象的最小值 (宏常量)
PTRDIFF_MAX (C++11)	std::ptrdiff_t 类型对象的最大值 (宏常量)
SIZE_MAX (C++11)	std::size_t 类型对象的最大值 (宏常量)
SIG_ATOMIC_MIN (C++11)	std::sig_atomic_t 类型对象的最小值 (宏常量)
SIG_ATOMIC_MAX (C++11)	std::sig_atomic_t 类型对象的最大值 (宏常量)
WCHAR_MIN (C++11)	wchar_t 类型对象的最小值 (宏常量)
WCHAR_MAX (C++11)	wchar_t 类型对象的最大值 (宏常量)
WINT_MIN (C++11)	std::wint_t 类型对象的最小值 (宏常量)
WINT_MAX (C++11)	std::wint_t 类型对象的最大值 (宏常量)

 

整数类型极限

定义于头文件
CHAR_BIT	字节的位数 (宏常量)
MB_LEN_MAX	多字节字符的最大字节数 (宏常量)
CHAR_MIN	char 的最小值 (宏常量)
CHAR_MAX	char 的最大值 (宏常量)
SCHAR_MINSHRT_MININT_MINLONG_MINLLONG_MIN (C++11)	分别为 signed char、short、int、long 及 long long 的最小值 (宏常量)
SCHAR_MAXSHRT_MAXINT_MAXLONG_MAXLLONG_MAX (C++11)	分别为 signed char、short、int、long 及 long long 的最大值 (宏常量)
UCHAR_MAXUSHRT_MAXUINT_MAXULONG_MAXULLONG_MAX (C++11)	分别为 unsigned char、unsigned short、unsigned int、 unsigned long 及 unsigned long long 的最大值 (宏常量)

 注意：这些常量，除了 CHAR_BIT 和 MB_LEN_MAX ，都要求其类型匹配整数提升的结果，一如应用于它们所描述的类型的对象： CHAR_MAX 可能拥有类型 int 或 unsigned int ，但决非 char 。同样地 USHRT_MAX 可能不拥有无符号类型：其类型可能是 int 。

浮点类型极限

定义于头文件
FLT_RADIX	所有三种浮点类型的表示所用的基数（整数底） (宏常量)
DECIMAL_DIG (C++11)	从 long double 转换到至少有 DECIMAL_DIG 位数字的十进制表示，再转换回 long double 为恒等转换：这是序列化/反序列化 long double 所要求的十进制精度（参阅 std::numeric_limits::max_digits10） (宏常量)
FLT_DECIMAL_DIGDBL_DECIMAL_DIGLDBL_DECIMAL_DIG (C++17)	从 float/double/long double 转换到至少有 FLT_DECIMAL_DIG/DBL_DECIMAL_DIG/LDBL_DECIMAL_DIG 位数字的十进制，再转换回原类型为恒等转换：这是序列化/反序列化浮点值所要求的十进制精度（参阅 std::numeric_limits::max_digits10）。分别定义为至少 6、10 和 10，对于 IEEE float 为 9，对于 IEEE double 为 17。 (宏常量)
FLT_MINDBL_MINLDBL_MIN	分别为 float、double 与 long double 的最小规格化正数值 (宏常量)
FLT_TRUE_MINDBL_TRUE_MINLDBL_TRUE_MIN (C++17)	分别为 float、double 与 long double 的最小正数值 (宏常量)
FLT_MAXDBL_MAXLDBL_MAX	分别为 float、double 与 long double 的最大值 (宏常量)
FLT_EPSILONDBL_EPSILONLDBL_EPSILON	分别为 1.0 和 float、double 及 long double 的下一个可表示值之差 (宏常量)
FLT_DIGDBL_DIGLDBL_DIG	保证能在文本→ float/double/long double →文本的往返转换中保留而不会因舍入或溢出发生改变的的十进制位数（解释参阅 std::numeric_limits::digits10） (宏常量)
FLT_MANT_DIGDBL_MANT_DIGLDBL_MANT_DIG	分别为能无精度损失地表示成 float、double 及 long double 的基数 FLT_RADIX 的数字位数 (宏常量)
FLT_MIN_EXPDBL_MIN_EXPLDBL_MIN_EXP	分别为能够使FLT_RADIX 的该整数减一次幂为规格化的 float、double 与 long double 的最小负整数 (宏常量)
FLT_MIN_10_EXPDBL_MIN_10_EXPLDBL_MIN_10_EXP	分别为能够使 10 的该整数减一次幂为规格化的 float、double 与 long double 的最小负整数 (宏常量)
FLT_MAX_EXPDBL_MAX_EXPLDBL_MAX_EXP	分别为能够使 FLT_RADIX 的该整数减一次幂为可表示的有限的 float、double 与 long double 的最大正整数 (宏常量)
FLT_MAX_10_EXPDBL_MAX_10_EXPLDBL_MAX_10_EXP	分别为能够使 10 的该整数减一次幂为可表示的有限的 float、double 与 long double 的最大正整数 (宏常量)
FLT_ROUNDS	浮点算术的默认舍入模式 (宏常量)
FLT_EVAL_METHOD (C++11)	指定进行所有算术运算所用的精度 (宏常量)
FLT_HAS_SUBNORMDBL_HAS_SUBNORMLDBL_HAS_SUBNORM (C++17)	指明类型是否支持非正规数值：-1 为不确定，0 为不支持，1 为支持。 (宏常量)

 调用示例

#include 
#include 
#include 
#include 

int main()
{
    //std::ptrdiff_t 类型对象的最小值
    printf("PTRDIFF_MIN:    %d\n",      PTRDIFF_MIN);
    //std::ptrdiff_t 类型对象的最大值
    printf("PTRDIFF_MAX:    %d\n",      PTRDIFF_MAX);
    //std::size_t 类型对象的最大值
    printf("SIZE_MAX:       %d\n",      SIZE_MAX);
    //std::sig_atomic_t 类型对象的最小值
    printf("SIG_ATOMIC_MIN: %d\n",      SIG_ATOMIC_MIN);
    //std::sig_atomic_t 类型对象的最大值
    printf("SIG_ATOMIC_MAX: %d\n",      SIG_ATOMIC_MAX);
    //wchar_t 类型对象的最小值
    printf("WCHAR_MIN:      %d\n",      WCHAR_MIN);
    //wchar_t 类型对象的最大值
    printf("WCHAR_MAX:      %d\n",      WCHAR_MAX);
    //std::wint_t 类型对象的最小值
    printf("WINT_MIN:       %d\n",      WINT_MIN);
    //std::wint_t 类型对象的最大值
    printf("WINT_MAX:       %d\n",      WINT_MAX);
    printf("\n");

    //整数类型极限
    //字节的位数
    printf("CHAR_BIT:       %d\n",      CHAR_BIT);
    //多字节字符的最大字节数
    printf("MB_LEN_MAX:     %d\n",      MB_LEN_MAX);
    //char 的最小值
    printf("CHAR_MIN:       %d\n",      CHAR_MIN);
    //char 的最大值
    printf("CHAR_MAX:       %d\n",      CHAR_MAX);
    printf("\n");

    //分别为 signed char、short、int、long 及 long long 的最小值
    printf("SCHAR_MIN:      %d\n",      SCHAR_MIN);
    printf("SHRT_MIN:       %d\n",      SHRT_MIN);
    printf("INT_MIN:        %d\n",      INT_MIN);
    printf("LONG_MIN:       %I32d\n",   LONG_MIN);
    printf("LLONG_MIN:      %I64d\n",   LLONG_MIN);
    printf("\n");

    //分别为 signed char、short、int、long 及 long long 的最大值
    printf("SCHAR_MAX:      %d\n",      SCHAR_MAX);
    printf("SHRT_MAX:       %d\n",      SHRT_MAX);
    printf("INT_MAX:        %d\n",      INT_MAX);
    printf("LONG_MAX:       %I32d\n",   LONG_MAX);
    printf("LLONG_MAX:      %I64d\n",   LLONG_MAX);
    printf("\n");

    //分别为 unsigned char、unsigned short、unsigned int、
    //unsigned long 及 unsigned long long 的最大值
    printf("UCHAR_MAX:      %d\n",      UCHAR_MAX);
    printf("USHRT_MAX:      %d\n",      USHRT_MAX);
    printf("UINT_MAX:       %d\n",      UINT_MAX);
    printf("ULONG_MAX:      %I32u\n",   ULONG_MAX);
    printf("ULLONG_MAX:     %I64u\n",   ULLONG_MAX);
    printf("\n");

    //浮点类型极限
    //所有三种浮点类型的表示所用的基数（整数底）
    printf("FLT_RADIX:      %d\n",      FLT_RADIX);
    //从 long double 转换到至少有 DECIMAL_DIG 位数字的十进制表示，
    //再转换回 long double 为恒等转换：这是序列化/反序列化 long double 所要求的十进制精度
    //（参阅 std::numeric_limits::max_digits10）
    printf("DECIMAL_DIG:    %d\n",      DECIMAL_DIG);
    printf("FLT_DECIMAL_DIG:%d\n",      FLT_DECIMAL_DIG);
    printf("DBL_DECIMAL_DIG:%d\n",      DBL_DECIMAL_DIG);
    printf("LDBL_DECIMAL_DIG:%d\n",     LDBL_DECIMAL_DIG);
    printf("\n");

    //分别为 float、double 与 long double 的最小规格化正数值
    printf("FLT_MIN:      %f\n",        FLT_MIN);
    printf("DBL_MIN:      %f\n",        DBL_MIN);
    printf("LDBL_MIN:     %lf\n",       LDBL_MIN);
    printf("\n");

    //分别为 float、double 与 long double 的最小正数值
    printf("FLT_TRUE_MIN:      %f\n",   FLT_TRUE_MIN);
    printf("DBL_TRUE_MIN:      %f\n",   DBL_TRUE_MIN);
    printf("LDBL_TRUE_MIN:     %lf\n",  LDBL_TRUE_MIN);
    printf("\n");

    //分别为 float、double 与 long double 的最大值
    printf("FLT_MAX:      %f\n",        FLT_MAX);
    printf("DBL_MAX:      %f\n",        DBL_MAX);
    printf("LDBL_MAX:     %lf\n",       LDBL_MAX);
    printf("\n");

    //分别为 1.0 和 float、double 及 long double 的下一个可表示值之差
    printf("FLT_EPSILON:  %f\n",        FLT_EPSILON);
    printf("DBL_EPSILON:  %f\n",        DBL_EPSILON);
    printf("LDBL_EPSILON: %lf\n",       LDBL_EPSILON);
    printf("\n");

    //保证能在文本→ float/double/long double →文本的往返转换中保留而不会
    //因舍入或溢出发生改变的的十进制位数（解释参阅 std::numeric_limits::digits10）
    printf("FLT_DIG:      %d\n",        FLT_DIG);
    printf("DBL_DIG:      %d\n",        DBL_DIG);
    printf("LDBL_DIG:     %d\n",        LDBL_DIG);
    printf("\n");

    //分别为能无精度损失地表示成 float、double 及 long double 的基数 FLT_RADIX 的数字位数
    printf("FLT_MANT_DIG: %d\n",        FLT_MANT_DIG);
    printf("DBL_MANT_DIG: %d\n",        DBL_MANT_DIG);
    printf("LDBL_MANT_DIG:%d\n",        LDBL_MANT_DIG);
    printf("\n");

    //分别为能够使FLT_RADIX 的该整数减一次幂为规格化的 float、double 与 long double 的最小负整数
    printf("FLT_MIN_EXP:  %d\n",        FLT_MIN_EXP);
    printf("DBL_MIN_EXP:  %d\n",        DBL_MIN_EXP);
    printf("LDBL_MIN_EXP: %d\n",        LDBL_MIN_EXP);
    printf("\n");

    //分别为能够使 10 的该整数减一次幂为规格化的 float、double 与 long double 的最小负整数
    printf("FLT_MIN_10_EXP:%d\n",       FLT_MIN_10_EXP);
    printf("DBL_MIN_10_EXP:%d\n",       DBL_MIN_10_EXP);
    printf("LDBL_MIN_10_EXP:%d\n",      LDBL_MIN_10_EXP);
    printf("\n");

    //分别为能够使 FLT_RADIX 的该整数减一次幂为可表示的有限的 float、double 与 long double 的最大正整数
    printf("FLT_MAX_EXP:    %d\n",      FLT_MAX_EXP);
    printf("DBL_MAX_EXP:    %d\n",      DBL_MAX_EXP);
    printf("LDBL_MAX_EXP:   %d\n",      LDBL_MAX_EXP);
    printf("\n");

    //分别为能够使 10 的该整数减一次幂为可表示的有限的 float、double 与 long double 的最大正整数
    printf("FLT_MAX_10_EXP: %d\n",      FLT_MAX_10_EXP);
    printf("DBL_MAX_10_EXP: %d\n",      DBL_MAX_10_EXP);
    printf("LDBL_MAX_10_EXP:%d\n",      LDBL_MAX_10_EXP);
    printf("\n");

    //浮点算术的默认舍入模式
    printf("FLT_ROUNDS:     %d\n",      FLT_ROUNDS);
    //指定进行所有算术运算所用的精度
    printf("FLT_EVAL_METHOD:%d\n",      FLT_EVAL_METHOD);
    //指明类型是否支持非正规数值：-1 为不确定，0 为不支持，1 为支持。
    printf("FLT_HAS_SUBNORM:%d\n",      FLT_HAS_SUBNORM);
    printf("DBL_HAS_SUBNORM:%d\n",      DBL_HAS_SUBNORM);
    printf("LDBL_HAS_SUBNORM:%d\n",     LDBL_HAS_SUBNORM);
    printf("\n");
    return 0;
}

输出

PTRDIFF_MIN:    -2147483648
PTRDIFF_MAX:    2147483647
SIZE_MAX:       -1
SIG_ATOMIC_MIN: -2147483648
SIG_ATOMIC_MAX: 2147483647
WCHAR_MIN:      0
WCHAR_MAX:      65535
WINT_MIN:       0
WINT_MAX:       65535

CHAR_BIT:       8
MB_LEN_MAX:     5
CHAR_MIN:       -128
CHAR_MAX:       127

SCHAR_MIN:      -128
SHRT_MIN:       -32768
INT_MIN:        -2147483648
LONG_MIN:       -2147483648
LLONG_MIN:      -9223372036854775808

SCHAR_MAX:      127
SHRT_MAX:       32767
INT_MAX:        2147483647
LONG_MAX:       2147483647
LLONG_MAX:      9223372036854775807

UCHAR_MAX:      255
USHRT_MAX:      65535
UINT_MAX:       -1
ULONG_MAX:      4294967295
ULLONG_MAX:     18446744073709551615

FLT_RADIX:      2
DECIMAL_DIG:    21
FLT_DECIMAL_DIG:9
DBL_DECIMAL_DIG:17
LDBL_DECIMAL_DIG:21

FLT_MIN:      0.000000
DBL_MIN:      0.000000
LDBL_MIN:     -0.000000

FLT_TRUE_MIN:      0.000000
DBL_TRUE_MIN:      0.000000
LDBL_TRUE_MIN:     0.000000

FLT_MAX:      340282346638528860000000000000000000000.000000
DBL_MAX:      1797693134862315700000000000000000000000000000
	      0000000000000000000000000000000000000000000000
	      0000000000000000000000000000000000000000000000
	      0000000000000000000000000000000000000000000000
	      0000000000000000000000000000000000000000000000
	      0000000000000000000000000000000000000000000000
	      000000000000000000000000000000000.000000
LDBL_MAX:     -1.#QNAN0

FLT_EPSILON:  0.000000
DBL_EPSILON:  0.000000
LDBL_EPSILON: -0.000000

FLT_DIG:      6
DBL_DIG:      15
LDBL_DIG:     18

FLT_MANT_DIG: 24
DBL_MANT_DIG: 53
LDBL_MANT_DIG:64

FLT_MIN_EXP:  -125
DBL_MIN_EXP:  -1021
LDBL_MIN_EXP: -16381

FLT_MIN_10_EXP:-37
DBL_MIN_10_EXP:-307
LDBL_MIN_10_EXP:-4931

FLT_MAX_EXP:    128
DBL_MAX_EXP:    1024
LDBL_MAX_EXP:   16384

FLT_MAX_10_EXP: 38
DBL_MAX_10_EXP: 308
LDBL_MAX_10_EXP:4932

FLT_ROUNDS:     1
FLT_EVAL_METHOD:2
FLT_HAS_SUBNORM:1
DBL_HAS_SUBNORM:1
LDBL_HAS_SUBNORM:1