std::numeric_limits

From cppreference.com

Defined in header `<limits>`

template< class T > class numeric_limits;

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

This information is provided via specializations of the numeric_limits template. The standard library makes available specializations for all fundamental 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<char16_t>; // C++11 feature template<> class numeric_limits<char32_t>; // C++11 feature 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>; template<> class numeric_limits<unsigned long long>; template<> class numeric_limits<float>; template<> class numeric_limits<double>; template<> class numeric_limits<long double>;

Additionally, a specialization exists for every cv-qualified version of each fundamental type, identical to the unqualified specialization, e.g. std::numeric_limits<const int>, std::numeric_limits<volatile int>, and std::numeric_limits<const volatile int> are provided and are equivalent to std::numeric_limits<int>.

The standard library types that are aliases of fundamental types (such as std::size_t or std::streamsize may also be examined with the std::numeric_limits type traits.

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


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)

[edit] 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)

[edit] Helper classes


float_round_style	indicates floating-point rounding modes (enum)

float_denorm_style	indicates floating-point denormalization modes (enum)

[edit] Relationship with C library macro constants

Specialization	Members
Specialization	`min()`	`lowest()` (C++11)	`max()`	`epsilon()`	`digits`	`digits10`	`min_exponent`	`min_exponent10`	`max_exponent`	`max_exponent10`	`radix`
`_{numeric_limits<}`bool`_>`											2
`_{numeric_limits<}`char`_>`	CHAR_MIN	CHAR_MIN	CHAR_MAX								2
`_{numeric_limits<}`signed char`_>`	SCHAR_MIN	SCHAR_MIN	SCHAR_MAX								2
`_{numeric_limits<}`unsigned char`_>`	0	0	UCHAR_MAX								2
`_{numeric_limits<}`wchar_t`_>`	WCHAR_MIN	WCHAR_MIN	WCHAR_MAX								2
`_{numeric_limits<}`char16_t`_>`	0	0	UINT_LEAST16_MAX								2
`_{numeric_limits<}`char32_t`_>`	0	0	UINT_LEAST32_MAX								2
`_{numeric_limits<}`short`_>`	SHRT_MIN	SHRT_MIN	SHRT_MAX								2
`_{numeric_limits<}`signed short`_>`	SHRT_MIN	SHRT_MIN	SHRT_MAX								2
`_{numeric_limits<}`unsigned short`_>`	0	0	USHRT_MAX								2
`_{numeric_limits<}`int`_>`	INT_MIN	INT_MIN	INT_MAX								2
`_{numeric_limits<}`signed int`_>`	INT_MIN	INT_MIN	INT_MAX								2
`_{numeric_limits<}`unsigned int`_>`	0	0	UINT_MAX								2
`_{numeric_limits<}`long`_>`	LONG_MIN	LONG_MIN	LONG_MAX								2
`_{numeric_limits<}`signed long`_>`	LONG_MIN	LONG_MIN	LONG_MAX								2
`_{numeric_limits<}`unsigned long`_>`	0	0	ULONG_MAX								2
`_{numeric_limits<}`long long`_>`	LLONG_MIN	LLONG_MIN	LLONG_MAX								2
`_{numeric_limits<}`signed long long`_>`	LLONG_MIN	LLONG_MIN	LLONG_MAX								2
`_{numeric_limits<}`unsigned long long`_>`	0	0	ULLONG_MAX								2
`_{numeric_limits<}`float`_>`	FLT_MIN	-FLT_MAX	FLT_MAX	FLT_EPSILON	FLT_MANT_DIG	FLT_DIG	FLT_MIN_EXP	FLT_MIN_10_EXP	FLT_MAX_EXP	FLT_MAX_10_EXP	FLT_RADIX
`_{numeric_limits<}`double`_>`	DBL_MIN	-DBL_MAX	DBL_MAX	DBL_EPSILON	DBL_MANT_DIG	DBL_DIG	DBL_MIN_EXP	DBL_MIN_10_EXP	DBL_MAX_EXP	DBL_MAX_10_EXP	FLT_RADIX
`_{numeric_limits<}`long double`_>`	LDBL_MIN	-LDBL_MAX	LDBL_MAX	LDBL_EPSILON	LDBL_MANT_DIG	LDBL_DIG	LDBL_MIN_EXP	LDBL_MIN_10_EXP	LDBL_MAX_EXP	LDBL_MAX_10_EXP	FLT_RADIX

[edit] Example

run this code

#include <limits>
#include <iostream>
 
int main() 
{
    std::cout << "type\tlowest\thighest\n";
    std::cout << "int\t"
              << std::numeric_limits<int>::lowest() << '\t'
              << std::numeric_limits<int>::max() << '\n';
    std::cout << "float\t"
              << std::numeric_limits<float>::lowest() << '\t'
              << std::numeric_limits<float>::max() << '\n';
    std::cout << "double\t"
              << std::numeric_limits<double>::lowest() << '\t'
              << std::numeric_limits<double>::max() << '\n';
}

Possible output:

type    lowest         highest
int     -2147483648    2147483647
float   -3.40282e+38   3.40282e+38
double  -1.79769e+308  1.79769e+308

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)

std::numeric_limits

Contents

[edit] Member constants

[edit] Member functions

[edit] Helper classes

[edit] Relationship with C library macro constants

[edit] Example