std::numeric_limits

template <class T> numeric_limits;

Numeric limits type

Provides information about the properties of arithmetic types (either integral or floating-point) in the specific platform for which the library compiles.

This class template is specialized for every fundamental arithmetic type, with its members describing the properties of type T. This template shall not be specialized for any other type.

Template parameters

T: A type.
If this is a fundamental arithmetic type, the members of the class describe its properties.

Template instantiations

fundamental arithmetic types
integral types	`bool`
	`char`
	`wchar_t`
	`signed char`
	`short int`
	`int`
	`long int`
	`unsigned char`
	`unsigned short int`
	`unsigned int`
	`unsigned long int`
floating point types	`float`
	`double`
	`long double`

For any other type, its default definition is used.

fundamental arithmetic types
integral types	`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`
floating point types	`float`
	`double`
	`long double`

This template is also specialized for all const and/or volatile qualifications of these types, with the same values as their unqualified specializations.

For any other type, its default definition is used.

Members that produce a value of type T are member functions, while members of specific types are static member constants:

Members

member	type	property
`is_specialized`	`bool`	`true` for all arithmetic types (i.e., those for which `numeric_limits` is specialized). `false` for all other types.
`min()`	`T`	Minimum finite value. For floating types with denormalization (variable number of exponent bits): minimum positive normalized value. Equivalent to `CHAR_MIN`, `SCHAR_MIN`, `SHRT_MIN`, `INT_MIN`, `LONG_MIN`, `LLONG_MIN`, `FLT_MIN`, `DBL_MIN`, `LDBL_MIN` or `0`, depending on type.
`max()`	`T`	Maximum finite value. Equivalent to `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` or `LDBL_MAX`, depending on type.
`lowest()`	`T`	Minimum finite value. (since C++11) For integral types: the same as `min()`. For floating-point types: implementation-dependent; generally, the negative of `max()`.
`digits`	`int`	For integer types: number of non-sign bits (`radix` base digits) in the representation. For floating types: number of digits (in `radix` base) in the mantissa (equivalent to `FLT_MANT_DIG`, `DBL_MANT_DIG` or `LDBL_MANT_DIG`).
`digits10`	`int`	Number of digits (in decimal base) that can be represented without change. Equivalent to `FLT_DIG`, `DBL_DIG` or `LDBL_DIG` for floating types.
`max_digits10`	`int`	Number of digits (in decimal base) required to ensure that values that differ are always differentiated.
`is_signed`	`bool`	`true` if type is signed.
`is_integer`	`bool`	`true` if type is integer.
`is_exact`	`bool`	`true` if type uses exact representations.
`radix`	`int`	For integer types: base of the representation. For floating types: base of the exponent of the representation (equivalent to `FLT_RADIX`).
`epsilon()`	`T`	Machine epsilon (the difference between 1 and the least value greater than 1 that is representable). Equivalent to `FLT_EPSILON`, `DBL_EPSILON` or `LDBL_EPSILON` for floating types.
`round_error()`	`T`	Measure of the maximum rounding error.
`min_exponent`	`int`	Minimum negative integer value such that `radix` raised to `(min_exponent-1)` generates a normalized floating-point number. Equivalent to `FLT_MIN_EXP`, `DBL_MIN_EXP` or `LDBL_MIN_EXP` for floating types.
`min_exponent10`	`int`	Minimum negative integer value such that 10 raised to that power generates a normalized floating-point number. Equivalent to `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP` or `LDBL_MIN_10_EXP` for floating types.
`max_exponent`	`int`	Maximum integer value such that `radix` raised to `(max_exponent-1)` generates a representable finite floating-point number. Equivalent to `FLT_MAX_EXP`, `DBL_MAX_EXP` or `LDBL_MAX_EXP` for floating types.
`max_exponent10`	`int`	Maximum integer value such that 10 raised to that power generates a normalized finite floating-point number. Equivalent to `FLT_MAX_10_EXP`, `DBL_MAX_10_EXP` or `LDBL_MAX_10_EXP` for floating types.
`has_infinity`	`bool`	`true` if the type has a representation for positive infinity.
`has_quiet_NaN`	`bool`	`true` if the type has a representation for a quiet (non-signaling) "Not-a-Number".
`has_signaling_NaN`	`bool`	`true` if the type has a representation for a signaling "Not-a-Number".
`has_denorm`	`float_denorm_style`	Denormalized values (representations with a variable number of exponent bits). A type may have any of the following enum values: `denorm_absent`, if it does not allow denormalized values. `denorm_present`, if it allows denormalized values. `denorm_indeterminate`, if indeterminate at compile time.
`has_denorm_loss`	`bool`	`true` if a loss of accuracy is detected as a denormalization loss, rather than an inexact result.
`infinity()`	`T`	Representation of positive infinity, if available.
`quiet_NaN()`	`T`	Representation of quiet (non-signaling) "Not-a-Number", if available.
`signaling_NaN()`	`T`	Representation of signaling "Not-a-Number", if available.
`denorm_min()`	`T`	Minimum positive denormalized value. For types not allowing denormalized values: same as `min()`.
`is_iec559`	`bool`	`true` if the type adheres to IEC-559 / IEEE-754 standard. An IEC-559 type always has `has_infinity`, `has_quiet_NaN` and `has_signaling_NaN` set to `true`; And `infinity`, `quiet_NaN` and `signaling_NaN` return some non-zero value.
`is_bounded`	`bool`	`true` if the set of values represented by the type is finite.
`is_modulo`	`bool`	`true` if the type is modulo. A type is modulo if it is possible to add two positive numbers and have a result that wraps around to a third number that is less.
`traps`	`bool`	`true` if trapping is implemented for the type.
`tinyness_before`	`bool`	`true` if tinyness is detected before rounding.
`round_style`	`float_round_style`	Rounding style. A type may have any of the following enum values: `round_toward_zero`, if it rounds toward zero. `round_to_nearest`, if it rounds to the nearest representable value. `round_toward_infinity`, if it rounds toward infinity. `round_toward_neg_infinity`, if it rounds toward negative infinity. `round_indeterminate`, if the rounding style is indeterminable at compile time.

For all types that are not fundamental arithmetic types, the default template definition is used:

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;
};

All specializations shall also provide these values as constant expressions.

Example

// 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;
}

Possible output:


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

std::numeric_limits

Template parameters

Template instantiations

Members

Example

See also