std::numeric_limits
numeric_limits шаблон класса обеспечивает стандартизированный способ запроса различных свойств арифметических типов (например , наибольшее возможное значение для типа int является std::numeric_limits<int>::max() ).
Эта информация предоставляется через специализации шаблона numeric_limits . Стандартная библиотека делает доступными специализации для всех арифметических типов:
| Определено в заголовке <limits> |
|---|
| (since C++20) |
| (since C++11) |
| (since C++11) |
| (since C++11) |
| (since C++11) |
Кроме того, для каждой cv-квалифицированной версии каждого cv-неквалифицированного типа, для которого существует специализация, существует специализация, идентичная неквалифицированной специализации, например, std::numeric_limits<const int> , std::numeric_limits<volatile int> и std::numeric_limits<const volatile int> предоставляются и эквивалентны std::numeric_limits<int> .
Псевдонимы арифметических типов (например, std::size_t или std::streamsize ) также могут быть проверены с помощью признаков типа std::numeric_limits .
Неарифметические стандартные типы, такие как std::complex<T> или std::nullptr_t , не имеют специализаций.
Если в реализации определены какие -либо целочисленные типы , для них также должны быть предусмотрены специализации std::numeric_limits .
Реализации могут предоставлять специализации std::numeric_limits для конкретных типов реализации: например, GCC предоставляет std::numeric_limits<__int128> . Нестандартные библиотеки могут добавлять специализации для предоставляемых библиотекой типов, например, OpenEXR предоставляет std::numeric_limits<half> для 16-битного типа с плавающей запятой.
Numeric limits c что это
На этом шаге мы рассмотрим класс numeric_limits .
Обобщенный шаблон задает числовые пределы по умолчанию для произвольного типа:
Обобщенный шаблон числовых пределов указывает лишь на то, что для типа Т числовые пределы не определены. Для этого переменной is_specialized присваивается значение false .
Обобщенный шаблон numeric_limits и его стандартные специализации содержатся в заголовочном файле <limits> . Заголовок включает специализации для всех базовых типов, представляющих числовые значения: bool, char, signed char, unsigned char, wchar_t, short, unsigned short, int, unsigned int, long, unsigned long, float, double и long double . Кроме того, аналогичные специализации легко определяются для пользовательских числовых типов.
Numeric limits c что это
A class template for representing information about arithmetic types.
Synopsis
Specializations
Description
Members of class template numeric_limits provide information about the properties of the implementation’s fundamental arithmetic types. Specializations of the template are included for each arithmetic type. The program may specialize the primary template on user-defined types.
This class encapsulates information that is contained in the <climits> and <cfloat> headers, and includes additional information that is not contained in any existing C or C++ header.
Not all of the information given by members is meaningful for all specializations of numeric_limits . Any value that is not meaningful for a particular type is set to 0 or false .
Interface
Member Fields and Functions
Returns the minimum denormalized value. Meaningful for all floating point types. For types that do not allow denormalized values, this method must return the minimum normalized value.
The number of radix digits that can be represented without change. For built-in integer types, digits is usually the number of non-sign bits in the representation. For floating point types, digits is the number of radix digits in the mantissa. This member is meaningful for all specializations that declare is_bounded to be true .
The number of base 10 digits that can be represented without change. This function is meaningful for all specializations that declare is_bounded to be true .
Returns the machine epsilon (the difference between 1 and the least value greater than 1 that is representable). This function is meaningful for floating point types only.
Returns denorm_present if the type allows denormalized values. Returns denorm_absent if the type does not allow denormalized values. Returns denorm_indeterminate if it is indeterminate at compile time whether the type allows denormalized values. It is meaningful for floating point types only.
This field is true if a loss of accuracy can be attributed to denormalization. Meaningful for floating point types only.
This field is true if the type has a representation for positive infinity. It is meaningful for floating point types only. This field must be true for any type claiming conformance to IEC 559.
This field is true if the type has a representation for a quiet (non-signaling) «Not a Number». It is meaningful for floating point types only and must be true for any type claiming conformance to IEC 559.
This field is true if the type has a representation for a signaling «Not a Number». It is meaningful for floating point types only, and must be true for any type claiming conformance to IEC 559.
Returns the representation of positive infinity, if available. This member function is meaningful for only those specializations that declare has_infinity to be true . Required for any type claiming conformance to IEC 559.
This field is true if the set of values representable by the type is finite. All built-in C types are bounded; this member would be false for arbitrary precision types.
This static member field is true if the type uses an exact representation. All integer types are exact, but not vice versa. For example, rational and fixed-exponent representations are exact but not integer. This member is meaningful for all specializations.
This member is true if and only if the type adheres to the IEC 559 standard. It is meaningful for floating point types only.
This member is true if the type is integer. This member is meaningful for all specializations.
This field is true if the type is modulo. Generally, this is false for floating types, true for unsigned integers, and true for signed integers on most machines. A type is modulo if it is possible to add two positive numbers and have a result that wraps around to a third number, which is less.
This member is true if the type is signed. This member is meaningful for all specializations.
Indicates whether numeric_limits has been specialized for type T . This flag must be true for all specializations of numeric_limits . For the default numeric_limits template, this flag must be false .
Returns the maximum finite value. This function is meaningful for all specializations for which is_bounded == true .
The maximum positive integer such that the radix raised to the power one less than that integer is in range. This field is meaningful for floating point types only.
The maximum positive integer such that 10 raised to that power is in range. This field is meaningful for floating point types only.
Returns the minimum finite value. For floating point types with denormalization, min() must return the minimum normalized value. The minimum denormalized value is given by denorm_min() . This function is meaningful for all specializations for which is_bounded == true , or for which is_bounded == false && is_signed == false .
The minimum negative integer such that the radix raised to the power one less than that integer is in range. This field is meaningful for floating point types only.
The minimum negative integer such that 10 raised to that power is in range. This field is meaningful for floating point types only.
Returns the representation of a quiet «Not a Number», if available. This function is meaningful only for those specializations that declare has_quiet_NaN to be true . This field is required for any type claiming conformance to IEC 559.
For floating types, specifies the base or radix of the exponent representation (often 2). For integer types, this member must specify the base of the representation. This field is meaningful for all specializations.
Returns the measure of the maximum rounding error. This function is meaningful for floating point types only.
The rounding style for the type. Specializations for integer types must return round_toward_zero . This is meaningful for all floating point types.
Returns the representation of a signaling «Not a Number», if available. This function is meaningful for only those specializations that declare has_signaling_NaN to be true . This function must be meaningful for any type claiming conformance to IEC 559.
This member is true if tinyness is detected before rounding. It is meaningful for floating point types only.
This field is true if trapping is implemented for this type. The traps field is meaningful for all specializations.
Warnings
The specializations for wide chars and bool are only available if your compiler has implemented them as real types and not simulated them with typedefs.
See Also
IEEE Standard for Binary Floating-Point Arithmetic, 345 East 47th Street, New York, NY 10017
Language Independent Arithmetic (LIA-1)
Standards Conformance
ISO/IEC 14882:1998 — International Standard for Information Systems — Programming Language C++, Section 18.2.1
18 Language support library [language.support]
18.3 Implementation properties [support.limits]
18.3.2 Numeric limits [limits]
18.3.2.1 Class template numeric_limits [limits.numeric]
The numeric_limits class template provides a C++ program with information about various properties of the implementation’s representation of the arithmetic types.
Specializations shall be provided for each arithmetic type, both floating-point and integer, including bool . The member is_specialized shall be true for all such specializations of numeric_limits .
For all members declared static constexpr in the numeric_limits template, specializations shall define these values in such a way that they are usable as constant expressions.
Non-arithmetic standard types, such as complex<T> ([complex]), shall not have specializations.
18.3.2.2 Header <limits> synopsis [limits.syn]
18.3.2.3 Class template numeric_limits [numeric.limits]
The default numeric_limits<T> template shall have all members, but with 0 or false values.
The value of each member of a specialization of numeric_limits on a cv-qualified type cv T shall be equal to the value of the corresponding member of the specialization on the unqualified type T .
18.3.2.4 numeric_limits members [numeric.limits.members]
static constexpr T min() noexcept;
Minimum finite value.189
For floating types with denormalization, returns the minimum positive normalized value.
Meaningful for all specializations in which is_bounded != false , or is_bounded == false && is_signed == false .
static constexpr T max() noexcept;
Maximum finite value.190
Meaningful for all specializations in which is_bounded != false .
static constexpr T lowest() noexcept;
A finite value x such that there is no other finite value y where y < x .191
Meaningful for all specializations in which is_bounded != false .
static constexpr int digits;
Number of radix digits that can be represented without change.
For integer types, the number of non-sign bits in the representation.
For floating-point types, the number of radix digits in the mantissa.192
static constexpr int digits10;
Number of base 10 digits that can be represented without change.193
Meaningful for all specializations in which is_bounded != false .
static constexpr int max_digits10;
Number of base 10 digits required to ensure that values which differ are always differentiated.
Meaningful for all floating-point types.
static constexpr bool is_signed;
True if the type is signed.
Meaningful for all specializations.
static constexpr bool is_integer;
True if the type is integer.
Meaningful for all specializations.
static constexpr bool is_exact;
True if the type uses an exact representation. All integer types are exact, but not all exact types are integer. For example, rational and fixed-exponent representations are exact but not integer.
Meaningful for all specializations.
static constexpr int radix;
For floating types, specifies the base or radix of the exponent representation (often 2).194
For integer types, specifies the base of the representation.195
Meaningful for all specializations.
static constexpr T epsilon() noexcept;
Machine epsilon: the difference between 1 and the least value greater than 1 that is representable.196
Meaningful for all floating-point types.
static constexpr T round_error() noexcept;
Measure of the maximum rounding error.197
static constexpr int min_exponent;
Minimum negative integer such that radix raised to the power of one less than that integer is a normalized floating point number.198
Meaningful for all floating-point types.
static constexpr int min_exponent10;
Minimum negative integer such that 10 raised to that power is in the range of normalized floating-point numbers.199
Meaningful for all floating-point types.
static constexpr int max_exponent;
Maximum positive integer such that radix raised to the power one less than that integer is a representable finite floating-point number.200
Meaningful for all floating-point types.
static constexpr int max_exponent10;
Maximum positive integer such that 10 raised to that power is in the range of representable finite floating-point numbers.201
Meaningful for all floating-point types.
static constexpr bool has_infinity;
True if the type has a representation for positive infinity.
Meaningful for all floating-point types.
Shall be true for all specializations in which is_iec559 != false .
static constexpr bool has_quiet_NaN;
True if the type has a representation for a quiet (non-signaling) “Not a Number.”202
Meaningful for all floating-point types.
Shall be true for all specializations in which is_iec559 != false .
static constexpr bool has_signaling_NaN;
True if the type has a representation for a signaling “Not a Number.”203
Meaningful for all floating-point types.
Shall be true for all specializations in which is_iec559 != false .
static constexpr float_denorm_style has_denorm;
denorm_present if the type allows denormalized values (variable number of exponent bits)204, denorm_absent if the type does not allow denormalized values, and denorm_indeterminate if it is indeterminate at compile time whether the type allows denormalized values.
Meaningful for all floating-point types.
static constexpr bool has_denorm_loss;
True if loss of accuracy is detected as a denormalization loss, rather than as an inexact result.205
static constexpr T infinity() noexcept;
Representation of positive infinity, if available.206
Meaningful for all specializations for which has_infinity != false . Required in specializations for which is_iec559 != false .
static constexpr T quiet_NaN() noexcept;
Representation of a quiet “Not a Number,” if available.207
Meaningful for all specializations for which has_quiet_NaN != false . Required in specializations for which is_iec559 != false .
static constexpr T signaling_NaN() noexcept;
Representation of a signaling “Not a Number,” if available.208
Meaningful for all specializations for which has_signaling_NaN != false . Required in specializations for which is_iec559 != false .
static constexpr T denorm_min() noexcept;
Minimum positive denormalized value.209
Meaningful for all floating-point types.
In specializations for which has_denorm == false , returns the minimum positive normalized value.
static constexpr bool is_iec559;
True if and only if the type adheres to ISO/IEC/IEEE 60559.210
Meaningful for all floating-point types.
static constexpr bool is_bounded;
True if the set of values representable by the type is finite.211 [ Note: All fundamental types ([basic.fundamental]) are bounded. This member would be false for arbitrary precision types. — end note ]
Meaningful for all specializations.
static constexpr bool is_modulo;
True if the type is modulo.212 A type is modulo if, for any operation involving + , — , or * on values of that type whose result would fall outside the range [min(), max()] , the value returned differs from the true value by an integer multiple of max() — min() + 1 .
[ Example: is_modulo is false for signed integer types ([basic.fundamental]) unless an implementation, as an extension to this International Standard, defines signed integer overflow to wrap. — end example ]
Meaningful for all specializations.
static constexpr bool traps;
true if, at program startup, there exists a value of the type that would cause an arithmetic operation using that value to trap.213
Meaningful for all specializations.
static constexpr bool tinyness_before;
true if tinyness is detected before rounding.214
Meaningful for all floating-point types.
static constexpr float_round_style round_style;
The rounding style for the type.215
Meaningful for all floating-point types. Specializations for integer types shall return round_toward_zero .
Equivalent to CHAR_MIN , SHRT_MIN , FLT_MIN , DBL_MIN , etc.
Equivalent to CHAR_MAX , SHRT_MAX , FLT_MAX , DBL_MAX , etc.
lowest() is necessary because not all floating-point representations have a smallest (most negative) value that is the negative of the largest (most positive) finite value.
Equivalent to FLT_MANT_DIG , DBL_MANT_DIG , LDBL_MANT_DIG .
Equivalent to FLT_DIG , DBL_DIG , LDBL_DIG .
Equivalent to FLT_RADIX .
Distinguishes types with bases other than 2 (e.g. BCD).
Equivalent to FLT_EPSILON , DBL_EPSILON , LDBL_EPSILON .
Rounding error is described in ISO/IEC 10967-1 Language independent arithmetic — Part 1 Section 5.2.8 and Annex A Rationale Section A.5.2.8 — Rounding constants.