A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://en.cppreference.com/w/cpp/language/../named_req/../types/numeric_limits.html below:

std::numeric_limits - cppreference.com

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):

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.

[edit] Template parameters T - a type to retrieve numeric properties for [edit] Member constants identifies types for which std::numeric_limits is specialized
(public static member constant) [edit] identifies signed types
(public static member constant) [edit] identifies integer types
(public static member constant) [edit] identifies exact types
(public static member constant) [edit] identifies floating-point types that can represent the special value "positive infinity"
(public static member constant) [edit] identifies floating-point types that can represent the special value "quiet not-a-number" (NaN)
(public static member constant) [edit] identifies floating-point types that can represent the special value "signaling not-a-number" (NaN)
(public static member constant) [edit] identifies the denormalization style used by the floating-point type
(public static member constant) [edit] identifies the floating-point types that detect loss of precision as denormalization loss rather than inexact result
(public static member constant) [edit] identifies the rounding style used by the type
(public static member constant) [edit] identifies the IEC 559/IEEE 754 floating-point types
(public static member constant) [edit] identifies types that represent a finite set of values
(public static member constant) [edit] identifies types that handle overflows with modulo arithmetic
(public static member constant) [edit] number of radix digits that can be represented without change
(public static member constant) [edit] number of decimal digits that can be represented without change
(public static member constant) [edit] number of decimal digits necessary to differentiate all values of this type
(public static member constant) [edit] the radix or integer base used by the representation of the given type
(public static member constant) [edit] one more than the smallest negative power of the radix that is a valid normalized floating-point value
(public static member constant) [edit] the smallest negative power of ten that is a valid normalized floating-point value
(public static member constant) [edit] one more than the largest integer power of the radix that is a valid finite floating-point value
(public static member constant) [edit] the largest integer power of 10 that is a valid finite floating-point value
(public static member constant) [edit] identifies types which can cause arithmetic operations to trap
(public static member constant) [edit] identifies floating-point types that detect tinyness before rounding
(public static member constant) [edit] [edit] Member functions returns the smallest finite value of the given non-floating-point type, or the smallest positive normal value of the given floating-point type
(public static member function) [edit] returns the lowest finite value of the given type, i.e. the most negative value for signed types, ​0​ for unsigned types
(public static member function) [edit] returns the largest finite value of the given type
(public static member function) [edit] returns the difference between 1.0 and the next representable value of the given floating-point type
(public static member function) [edit] returns the maximum rounding error of the given floating-point type
(public static member function) [edit] returns the positive infinity value of the given floating-point type
(public static member function) [edit] returns a quiet NaN value of the given floating-point type
(public static member function) [edit] returns a signaling NaN value of the given floating-point type
(public static member function) [edit] returns the smallest positive subnormal value of the given floating-point type
(public static member function) [edit] [edit] Helper classes [edit] Relationship with C library macro constants [edit] Example
#include <iostream>
#include <limits>
 
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
[edit] 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 [edit] See also

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4