std::numeric_limits< T const volatile > Class Template Reference

Traits class to provide information about the representation of arithmetic types. More...

Inheritance diagram for std::numeric_limits< T const volatile >:

Additional Inherited Members
Static Public Member Functions inherited from std::numeric_limits_detail::numeric_limits_impl< T, typename >
static constexpr auto	denorm_min () noexcept -> T
	For floating point types, the minimum positive denormalized value. If the representation has no denormalized values, the minimum positive normalized value.
static constexpr auto	epsilon () noexcept -> T
	For floating point types, the epsilon value: the difference between 1 and the least representable value greater than 1.
static constexpr auto	infinity () noexcept -> T
	For floating point types where has_infinity is true, a representation of positive infinity.
static constexpr auto	lowest () noexcept -> T
	The minimum finite value such that there is no finite value y such that y<lowest()
static constexpr auto	max () noexcept -> T
	The maximum finite value.
static constexpr auto	min () noexcept -> T
	The minimum finite value; the minimum positive normalized value for floating point types.
static constexpr auto	quiet_NaN () noexcept -> T
	For floating point types where has_quiet_NaN is true, a representation of a quiet NaN.
static constexpr auto	round_error () noexcept -> T
	For floating point types, the maximum rounding error.
static constexpr auto	signaling_NaN () noexcept -> T
	For floating point types where has_signaling_NaN is true, a representation of a signaling NaN.
Static Public Attributes inherited from std::numeric_limits_detail::numeric_limits_impl< T, typename >
static constexpr int	digits {0}
	The number of radix digits in the representation, ignoring any sign bit.
static constexpr int	digits10 {0}
	The maximum number of base-10 digits that can be completely represented in values of the type.
static constexpr float_denorm_style	has_denorm {denorm_absent}
	For floating point types, an indicator of whether the type has a representation of denormalized values.
static constexpr bool	has_denorm_loss {false}
	For floating point types, true if loss of accuracy is detected as a denormalization loss rather than an inexact result, otherwise false.
static constexpr bool	has_infinity {false}
	For floating point types, true if the type has a representation of positive infinity, otherwise false.
static constexpr bool	has_quiet_NaN {false}
	For floating point types, true if the type has a representation of a quiet (non-signaling) "Not-a-Number", otherwise false.
static constexpr bool	has_signaling_NaN {false}
	For floating point types, true if the type has a representation of a signaling "Not-a-Number", otherwise false.
static constexpr bool	is_bounded {false}
	true if the set of values representable by the type is bounded, otherwise false
static constexpr bool	is_exact {false}
	Is the type an exact type? true if so, false otherwise.
static constexpr bool	is_iec559 {false}
	For floating point types, true if the type adheres to the IEC559 standard, otherwise false.
static constexpr bool	is_integer {false}
	Is the type an integral type? true if so, false otherwise.
static constexpr bool	is_modulo {false}
	true if the set of values representable by the type is modulo, otherwise false
static constexpr bool	is_signed {false}
	Is the type a signed type? true if so, false otherwise.
static constexpr bool	is_specialized {false}
	Is this a specialization for which the other values are meaningful? true if so, false otherwise.
static constexpr int	max_digits10 {0}
	For floating point types, the number of base-10 digits required to ensure that values which differ can be differentiated.
static constexpr int	max_exponent {0}
	For floating point types, the maximum positive integer such that radix raised to the power of one less than that integer is a representable finite floating point number.
static constexpr int	max_exponent10 {0}
	For floating point types, the maximum positive integer such that 10 raised to the power of one less than that integer is in the range of representable finite floating point numbers.
static constexpr int	min_exponent {0}
	For floating point types, the minimum negative integer such that radix raised to the power of one less than that integer is a normalized floating point number.
static constexpr int	min_exponent10 {0}
	For floating point types, the minimum negative integer such that 10 raised to the power of one less than that integer is in the range of normalized floating point numbers.
static constexpr int	radix {0}
	The base used for the representation.
static constexpr float_round_style	round_style {round_toward_zero}
	For floating point types, an indicator of the default rounding style.
static constexpr bool	tinyness_before {false}
	For floating point types, true if tinyness is detected before rounding, otherwise false.
static constexpr bool	traps {false}
	true if there are trap representations of this type, otherwise false

Detailed Description

template<typename T>
class std::numeric_limits< T const volatile >

Traits class to provide information about the representation of arithmetic types.

The primary template is for non-arithmetic types, and provides default values of all the traits, which are zero, false, or default-constructed as appropriate. Specializations are provided for all built-in arithmetic types which provide appropriate values of all fields.

Template Parameters

T	The type for which to query information

---

The documentation for this class was generated from the following file:

• stdlib/include/stdlib_detail/numeric_limits.hpp