std::numeric_limits

template <class T> numeric_limits;

数字限制类型

为编译此库的特定平台上的所有*算术类型*（整数类型或浮点类型）提供有关属性的信息。

这个类模板为每个*基本算术类型*进行了特化，其成员描述了类型T的属性。这个模板不应对任何其他类型进行特化。

模板参数

T: 一个类型。
如果这是一个*基本算术类型*，那么该类的成员将描述它的属性。

sub_match for string literals (class)

基本算术类型
整数类型	`bool`
	`char`
	`wchar_t`
	`signed char`
	`short int`
	`int`
	`long int`
	`unsigned char`
	`unsigned short int`
	`unsigned int`
	`unsigned long int`
浮点类型	`float`
	`double`
	`long double`

对于任何其他类型，将使用其默认定义。

基本算术类型
整数类型	`bool`
	`char`
	`char16_t`
	`char32_t`
	`wchar_t`
	`signed char`
	`short int`
	`int`
	`long int`
	`long long int`
	`unsigned char`
	`unsigned short int`
	`unsigned int`
	`unsigned long int`
	`unsigned long long int`
浮点类型	`float`
	`double`
	`long double`

此模板还为所有这些类型的const和/或volatile限定版本进行了特化，其值与无限定的特化相同。

对于任何其他类型，将使用其默认定义。

生成类型T的成员是成员函数，而特定类型的成员是静态成员常量。

成员

成员	类型	属性
`is_specialized`	`bool`	对于所有算术类型（即`numeric_limits`特化的类型）为`true`。对于所有其他类型为`false`。
`min()`	`T`	最小有限值。对于具有反规格化（指数位数可变）的浮点类型：最小正规格化值。取决于类型，等同于`CHAR_MIN`、`SCHAR_MIN`、`SHRT_MIN`、`INT_MIN`、`LONG_MIN`、`LLONG_MIN`、`FLT_MIN`、`DBL_MIN`、`LDBL_MIN`或`0`。
`max()`	`T`	最大有限值。取决于类型，等同于`CHAR_MAX`、`SCHAR_MAX`、`UCHAR_MAX`、`SHRT_MAX`、`USHRT_MAX`、`INT_MAX`、`UINT_MAX`、`LONG_MAX`、`ULONG_MAX`、`LLONG_MAX`、`ULLONG_MAX`、`UINT_LEAST16_MAX`、`UINT_LEAST32_MAX`、`FLT_MAX`、`DBL_MAX`或`LDBL_MAX`。
`lowest()`	`T`	最小有限值。（自C++11起）对于整数类型：与`min()`相同。对于浮点类型：实现定义；通常是`max()`的负值。
`digits`	`int`	对于整数类型：表示中非符号位的数量（`radix`进制数字）。对于浮点类型：尾数中的数字数量（`radix`进制）；等同于`FLT_MANT_DIG`、`DBL_MANT_DIG`或`LDBL_MANT_DIG`）。
`digits10`	`int`	能够不改变地表示的（十进制）数字数量。对于浮点类型，等同于`FLT_DIG`、`DBL_DIG`或`LDBL_DIG`。
`max_digits10`	`int`	为了确保不同值总是能被区分而需要的（十进制）数字数量。
`is_signed`	`bool`	如果类型是有符号的，则为`true`。
`is_integer`	`bool`	如果类型是整数，则为`true`。
`is_exact`	`bool`	如果类型使用精确表示，则为`true`。
`radix`	`int`	对于整数类型：表示的基数。对于浮点类型：表示中指数的基数（等同于`FLT_RADIX`）。
`epsilon()`	`T`	机器epsilon（1与大于1的最小可表示值之间的差）。对于浮点类型，等同于`FLT_EPSILON`、`DBL_EPSILON`或`LDBL_EPSILON`。
`round_error()`	`T`	最大舍入误差的度量。
`min_exponent`	`int`	最小负整数值，使得`radix`的`(min_exponent-1)`次方生成一个规格化的浮点数。对于浮点类型，等同于`FLT_MIN_EXP`、`DBL_MIN_EXP`或`LDBL_MIN_EXP`。
`min_exponent10`	`int`	最小负整数值，使得10的该次方生成一个规格化的浮点数。对于浮点类型，等同于`FLT_MIN_10_EXP`、`DBL_MIN_10_EXP`或`LDBL_MIN_10_EXP`。
`max_exponent`	`int`	最大整数值，使得`radix`的`(max_exponent-1)`次方生成一个可表示的有限浮点数。对于浮点类型，等同于`FLT_MAX_EXP`、`DBL_MAX_EXP`或`LDBL_MAX_EXP`。
`max_exponent10`	`int`	最大整数值，使得10的该次方生成一个规格化的有限浮点数。对于浮点类型，等同于`FLT_MAX_10_EXP`、`DBL_MAX_10_EXP`或`LDBL_MAX_10_EXP`。
`has_infinity`	`bool`	如果类型有正无穷大的表示，则为`true`。
`has_quiet_NaN`	`bool`	如果类型有安静（非信号）“非数字”（NaN）的表示，则为`true`。
`has_signaling_NaN`	`bool`	如果类型有信号“非数字”（NaN）的表示，则为`true`。
`has_denorm`	`float_denorm_style`	反规格化值（指数位数可变的表示）。一个类型可能具有以下任一枚举值： `denorm_absent`，如果它不允许反规格化值。 `denorm_present`，如果它允许反规格化值。 `denorm_indeterminate`，如果编译时无法确定。
`has_denorm_loss`	`bool`	如果精度损失被检测为反规格化损失，而不是不精确的结果，则为`true`。
`infinity()`	`T`	如果可用，则为正无穷大的表示。
`quiet_NaN()`	`T`	如果可用，则为安静（非信号）“非数字”（NaN）的表示。
`signaling_NaN()`	`T`	如果可用，则为信号“非数字”（NaN）的表示。
`denorm_min()`	`T`	最小正反规格化值。对于不允许反规格化值的类型：与`min()`相同。
`is_iec559`	`bool`	如果类型符合IEC-559 / IEEE-754标准，则为`true`。 IEC-559类型总是具有`has_infinity`、`has_quiet_NaN`和`has_signaling_NaN`设置为`true`；并且`infinity`、`quiet_NaN`和`signaling_NaN`返回非零值。
`is_bounded`	`bool`	如果类型表示的值集是有限的，则为`true`。
`is_modulo`	`bool`	如果类型是模运算的，则为`true`。如果两个正数相加后结果会回绕成一个更小的第三个数，则该类型为模运算类型。
`traps`	`bool`	如果为该类型实现了陷阱（trapping），则为`true`。
`tinyness_before`	`bool`	如果在舍入之前检测到微小值（tinyness），则为`true`。
`round_style`	`float_round_style`	舍入风格。一个类型可能具有以下任一枚举值： `round_toward_zero`，如果它向零舍入。 `round_to_nearest`，如果它舍入到最近的可表示值。 `round_toward_infinity`，如果它向无穷大舍入。 `round_toward_neg_infinity`，如果它向负无穷大舍入。 `round_indeterminate`，如果舍入风格在编译时无法确定。

对于所有不是*基本算术类型*的类型，将使用默认的模板定义。

template <class T> class numeric_limits {
public:
  static const bool is_specialized = false;
  static T min() throw();
  static T max() throw();
  static const int  digits = 0;
  static const int  digits10 = 0;
  static const bool is_signed = false;
  static const bool is_integer = false;
  static const bool is_exact = false;
  static const int radix = 0;
  static T epsilon() throw();
  static T round_error() throw();

  static const int  min_exponent = 0;
  static const int  min_exponent10 = 0;
  static const int  max_exponent = 0;
  static const int  max_exponent10 = 0;

  static const bool has_infinity = false;
  static const bool has_quiet_NaN = false;
  static const bool has_signaling_NaN = false;
  static const float_denorm_style has_denorm = denorm_absent;
  static const bool has_denorm_loss = false;
  static T infinity() throw();
  static T quiet_NaN() throw();
  static T signaling_NaN() throw();
  static T denorm_min() throw();

  static const bool is_iec559 = false;
  static const bool is_bounded = false;
  static const bool is_modulo = false;

  static const bool traps = false;
  static const bool tinyness_before = false;
  static const float_round_style round_style = round_toward_zero;
};

template <class T> class numeric_limits {
public:
  static constexpr bool is_specialized = false;
  static constexpr T min() noexcept { return T(); }
  static constexpr T max() noexcept { return T(); }
  static constexpr T lowest() noexcept { return T(); }
  static constexpr int  digits = 0;
  static constexpr int  digits10 = 0;
  static constexpr bool is_signed = false;
  static constexpr bool is_integer = false;
  static constexpr bool is_exact = false;
  static constexpr int radix = 0;
  static constexpr T epsilon() noexcept { return T(); }
  static constexpr T round_error() noexcept { return T(); }

  static constexpr int  min_exponent = 0;
  static constexpr int  min_exponent10 = 0;
  static constexpr int  max_exponent = 0;
  static constexpr int  max_exponent10 = 0;

  static constexpr bool has_infinity = false;
  static constexpr bool has_quiet_NaN = false;
  static constexpr bool has_signaling_NaN = false;
  static constexpr float_denorm_style has_denorm = denorm_absent;
  static constexpr bool has_denorm_loss = false;
  static constexpr T infinity() noexcept { return T(); }
  static constexpr T quiet_NaN() noexcept { return T(); }
  static constexpr T signaling_NaN() noexcept { return T(); }
  static constexpr T denorm_min() noexcept { return T(); }

  static constexpr bool is_iec559 = false;
  static constexpr bool is_bounded = false;
  static constexpr bool is_modulo = false;

  static constexpr bool traps = false;
  static constexpr bool tinyness_before = false;
  static constexpr float_round_style round_style = round_toward_zero;
};

所有特化也应将这些值提供为*常量表达式*。

示例

// numeric_limits example
#include <iostream>     // std::cout
#include <limits>       // std::numeric_limits

int main () {
  std::cout << std::boolalpha;
  std::cout << "Minimum value for int: " << std::numeric_limits<int>::min() << '\n';
  std::cout << "Maximum value for int: " << std::numeric_limits<int>::max() << '\n';
  std::cout << "int is signed: " << std::numeric_limits<int>::is_signed << '\n';
  std::cout << "Non-sign bits in int: " << std::numeric_limits<int>::digits << '\n';
  std::cout << "int has infinity: " << std::numeric_limits<int>::has_infinity << '\n';
  return 0;
}

可能的输出


Minimum value for int: -2147483648
Maximum value for int: 2147483647
int is signed: true
Non-sign bits in int: 31
int has infinity: false

另见

<climits> (limits.h): 整数类型的大小 (头文件)

<cfloat> (float.h): 浮点类型的特性 (头文件)