W3cubDocs

/C++

std::numeric_limits

Defined in header `<limits>`
template< class T > class numeric_limits;

The std::numeric_limits class template provides a standardized way to query various properties of arithmetic types (e.g. the largest possible value for type int is std::numeric_limits<int>::max()).

This information is provided via specializations of the std::numeric_limits template. The standard library makes available specializations for all arithmetic types (only lists the specializations for cv-unqualified arithmetic types):

Defined in header `<limits>`
template<> class numeric_limits<bool>;
template<> class numeric_limits<char>;
template<> class numeric_limits<signed char>;
template<> class numeric_limits<unsigned char>;
template<> class numeric_limits<wchar_t>;
template<> class numeric_limits<char8_t>;		(since C++20)
template<> class numeric_limits<char16_t>;		(since C++11)
template<> class numeric_limits<char32_t>;		(since C++11)
template<> class numeric_limits<short>;
template<> class numeric_limits<unsigned short>;
template<> class numeric_limits<int>;
template<> class numeric_limits<unsigned int>;
template<> class numeric_limits<long>;
template<> class numeric_limits<unsigned long>;
template<> class numeric_limits<long long>;		(since C++11)
template<> class numeric_limits<unsigned long long>;		(since C++11)
template<> class numeric_limits<float>;
template<> class numeric_limits<double>;
template<> class numeric_limits<long double>;

The value of each member of a specialization of std::numeric_limits on a cv-qualified type cv T is equal to the value of the corresponding member of the specialization on the unqualified type T. For example, std::numeric_limits<int>::digits is equal to std::numeric_limits<const int>::digits.

Aliases of arithmetic types (such as std::size_t or std::streamsize) may also be examined with the std::numeric_limits type traits.

Non-arithmetic standard types, such as std::complex<T> or std::nullptr_t, do not have specializations.

If the implementation defines any integer-class types, specializations of std::numeric_limits must also be provided for them.

(since C++20)

Implementations may provide specializations of std::numeric_limits for implementation-specific types: e.g. GCC provides std::numeric_limits<__int128>. Non-standard libraries may add specializations for library-provided types, e.g. OpenEXR provides std::numeric_limits<half> for a 16-bit floating-point type.

Template parameters

a type to retrieve numeric properties for

Member constants

is_specialized [static]	identifies types for which `std::numeric_limits` is specialized (public static member constant)
is_signed [static]	identifies signed types (public static member constant)
is_integer [static]	identifies integer types (public static member constant)
is_exact [static]	identifies exact types (public static member constant)
has_infinity [static]	identifies floating-point types that can represent the special value "positive infinity" (public static member constant)
has_quiet_NaN [static]	identifies floating-point types that can represent the special value "quiet not-a-number" (NaN) (public static member constant)
has_signaling_NaN [static]	identifies floating-point types that can represent the special value "signaling not-a-number" (NaN) (public static member constant)
has_denorm [static]	identifies the denormalization style used by the floating-point type (public static member constant)
has_denorm_loss [static]	identifies the floating-point types that detect loss of precision as denormalization loss rather than inexact result (public static member constant)
round_style [static]	identifies the rounding style used by the type (public static member constant)
is_iec559 [static]	identifies the IEC 559/IEEE 754 floating-point types (public static member constant)
is_bounded [static]	identifies types that represent a finite set of values (public static member constant)
is_modulo [static]	identifies types that handle overflows with modulo arithmetic (public static member constant)
digits [static]	number of `radix` digits that can be represented without change (public static member constant)
digits10 [static]	number of decimal digits that can be represented without change (public static member constant)
max_digits10 [static] (C++11)	number of decimal digits necessary to differentiate all values of this type (public static member constant)
radix [static]	the radix or integer base used by the representation of the given type (public static member constant)
min_exponent [static]	one more than the smallest negative power of the radix that is a valid normalized floating-point value (public static member constant)
min_exponent10 [static]	the smallest negative power of ten that is a valid normalized floating-point value (public static member constant)
max_exponent [static]	one more than the largest integer power of the radix that is a valid finite floating-point value (public static member constant)
max_exponent10 [static]	the largest integer power of 10 that is a valid finite floating-point value (public static member constant)
traps [static]	identifies types which can cause arithmetic operations to trap (public static member constant)
tinyness_before [static]	identifies floating-point types that detect tinyness before rounding (public static member constant)

Member functions

min [static]	returns the smallest finite value of the given type (public static member function)
lowest [static] (C++11)	returns the lowest finite value of the given type (public static member function)
max [static]	returns the largest finite value of the given type (public static member function)
epsilon [static]	returns the difference between `1.0` and the next representable value of the given floating-point type (public static member function)
round_error [static]	returns the maximum rounding error of the given floating-point type (public static member function)
infinity [static]	returns the positive infinity value of the given floating-point type (public static member function)
quiet_NaN [static]	returns a quiet NaN value of the given floating-point type (public static member function)
signaling_NaN [static]	returns a signaling NaN value of the given floating-point type (public static member function)
denorm_min [static]	returns the smallest positive subnormal value of the given floating-point type (public static member function)

Helper classes

float_round_style	indicates floating-point rounding modes (enum)
float_denorm_style	indicates floating-point denormalization modes (enum)

Relationship with C library macro constants

Specialization `std::numeric_limits<T>` where `T` is	Members
Specialization `std::numeric_limits<T>` where `T` is	`min()`	`lowest()` (C++11)	`max()`	`radix`
bool	`false`	`false`	`true`	`2`
char	`CHAR_MIN`	`CHAR_MIN`	`CHAR_MAX`	`2`
signed char	`SCHAR_MIN`	`SCHAR_MIN`	`SCHAR_MAX`	`2`
unsigned char	`0`	`0`	`UCHAR_MAX`	`2`
wchar_t	`WCHAR_MIN`	`WCHAR_MIN`	`WCHAR_MAX`	`2`
char8_t	`0`	`0`	`UCHAR_MAX`	`2`
char16_t	`0`	`0`	`UINT_LEAST16_MAX`	`2`
char32_t	`0`	`0`	`UINT_LEAST32_MAX`	`2`
short	`SHRT_MIN`	`SHRT_MIN`	`SHRT_MAX`	`2`
signed short	`SHRT_MIN`	`SHRT_MIN`	`SHRT_MAX`	`2`
unsigned short	`0`	`0`	`USHRT_MAX`	`2`
int	`INT_MIN`	`INT_MIN`	`INT_MAX`	`2`
signed int	`INT_MIN`	`INT_MIN`	`INT_MAX`	`2`
unsigned int	`0`	`0`	`UINT_MAX`	`2`
long	`LONG_MIN`	`LONG_MIN`	`LONG_MAX`	`2`
signed long	`LONG_MIN`	`LONG_MIN`	`LONG_MAX`	`2`
unsigned long	`0`	`0`	`ULONG_MAX`	`2`
long long	`LLONG_MIN`	`LLONG_MIN`	`LLONG_MAX`	`2`
signed long long	`LLONG_MIN`	`LLONG_MIN`	`LLONG_MAX`	`2`
unsigned long long	`0`	`0`	`ULLONG_MAX`	`2`

Specialization `std::numeric_limits<T>` where `T` is	Members
Specialization `std::numeric_limits<T>` where `T` is	`denorm_min()`	`min()`	`lowest()` (C++11)	`max()`	`epsilon()`	`digits`	`digits10`
float	`FLT_TRUE_MIN`	`FLT_MIN`	`-FLT_MAX`	`FLT_MAX`	`FLT_EPSILON`	`FLT_MANT_DIG`	`FLT_DIG`
double	`DBL_TRUE_MIN`	`DBL_MIN`	`-DBL_MAX`	`DBL_MAX`	`DBL_EPSILON`	`DBL_MANT_DIG`	`DBL_DIG`
long double	`LDBL_TRUE_MIN`	`LDBL_MIN`	`-LDBL_MAX`	`LDBL_MAX`	`LDBL_EPSILON`	`LDBL_MANT_DIG`	`LDBL_DIG`

Specialization `std::numeric_limits<T>` where `T` is	Members (continue)
Specialization `std::numeric_limits<T>` where `T` is	`min_exponent`	`min_exponent10`	`max_exponent`	`max_exponent10`	`radix`
float	`FLT_MIN_EXP`	`FLT_MIN_10_EXP`	`FLT_MAX_EXP`	`FLT_MAX_10_EXP`	`FLT_RADIX`
double	`DBL_MIN_EXP`	`DBL_MIN_10_EXP`	`DBL_MAX_EXP`	`DBL_MAX_10_EXP`	`FLT_RADIX`
long double	`LDBL_MIN_EXP`	`LDBL_MIN_10_EXP`	`LDBL_MAX_EXP`	`LDBL_MAX_10_EXP`	`FLT_RADIX`

Example

#include <limits>
#include <iostream>
 
int main() 
{
    std::cout
        << "type\t│ lowest()\t│ min()\t\t│ max()\n"
        << "bool\t│ "
        << std::numeric_limits<bool>::lowest() << "\t\t│ "
        << std::numeric_limits<bool>::min() << "\t\t│ "
        << std::numeric_limits<bool>::max() << '\n'
        << "uchar\t│ "
        << +std::numeric_limits<unsigned char>::lowest() << "\t\t│ "
        << +std::numeric_limits<unsigned char>::min() << "\t\t│ "
        << +std::numeric_limits<unsigned char>::max() << '\n'
        << "int\t│ "
        << std::numeric_limits<int>::lowest() << "\t│ "
        << std::numeric_limits<int>::min() << "\t│ "
        << std::numeric_limits<int>::max() << '\n'
        << "float\t│ "
        << std::numeric_limits<float>::lowest() << "\t│ "
        << std::numeric_limits<float>::min() << "\t│ "
        << std::numeric_limits<float>::max() << '\n'
        << "double\t│ "
        << std::numeric_limits<double>::lowest() << "\t│ "
        << std::numeric_limits<double>::min() << "\t│ "
        << std::numeric_limits<double>::max() << '\n';
}

Possible output:

type        │ lowest()        │ min()                │ max()
bool        │ 0                │ 0                │ 1
uchar        │ 0                │ 0                │ 255
int        │ -2147483648        │ -2147483648        │ 2147483647
float        │ -3.40282e+38        │ 1.17549e-38        │ 3.40282e+38
double        │ -1.79769e+308        │ 2.22507e-308        │ 1.79769e+308

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 201	C++98	specializations for all fundamental types need to be provided	excluded non-arithmetic types
LWG 559	C++98	it was unclear whether the `std::numeric_limits` specialization for a cv-qualified type behaves as the same as the corresponding specialization for the cv-unqualified type	they have the same behavior