std::numeric_limits - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::numeric_limits

From cppreference.com
< cpp‎ | types

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.

### [edit] Template parameters

T | - | a type to retrieve numeric properties for

### [edit] Member constants

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

### [edit] Member functions

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

### [edit] Helper classes

float_round_style | indicates floating-point rounding modes (enum) [edit]
float_denorm_style | indicates floating-point denormalization modes (enum) [edit]

### [edit] Relationship with C library macro constants

Specialization | Members
--- | ---
`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`>` |  |  |  |  |  |  |
`numeric_limits<` unsigned short`>` | ​0​ | ​0​ | USHRT_MAX |  |  |  |  |  |  |  | 2
`numeric_limits<` int`>` | INT_MIN | INT_MIN | INT_MAX |  |  |  |  |  |  |  | 2
`numeric_limits<` signed int`>` |  |  |  |  |  |  |
`numeric_limits<` unsigned int`>` | ​0​ | ​0​ | UINT_MAX |  |  |  |  |  |  |  | 2
`numeric_limits<` long`>` | LONG_MIN | LONG_MIN | LONG_MAX |  |  |  |  |  |  |  | 2
`numeric_limits<` signed long`>` |  |  |  |  |  |
`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`>` |  |  |  |  |  |  |
`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

### [edit] See also

- Fixed width integer types
- Arithmetic types
- C++ type system overview
- Type support (basic types, RTTI, type traits)

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/types/numeric_limits&oldid=67795"