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): 浮點型別的特性 (標頭檔案)