std::numeric_limits

Определён в заголовочном файле `<limits>`
template< class T > class numeric_limits;

Шаблон класса std::numeric_limits предоставляет стандартизированный способ получения различных свойств арифметических типов (например, наибольшее возможное значение типа int — std::numeric_limits<int>::max()).

Эта информация предоставляется с помощью специализаций шаблона std::numeric_limits. Стандартная библиотека предоставляет специализации для всех арифметических типов (здесь перечислены только специализации для арифметических типов без cv-квалификаторов):

Определён в заголовочном файле `<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>;		(начиная с C++20)
template<> class numeric_limits<char16_t>;		(начиная с C++11)
template<> class numeric_limits<char32_t>;		(начиная с 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>;		(начиная с C++11)
template<> class numeric_limits<unsigned long long>;		(начиная с C++11)
template<> class numeric_limits<float>;
template<> class numeric_limits<double>;
template<> class numeric_limits<long double>;

Значение каждого члена специализации std::numeric_limits для cv-квалифицированного типа cv T равно значению соответствующего члена специализации для типа без квалификаторов T. Например, std::numeric_limits<int>::digits равно std::numeric_limits<const int>::digits.

Псевдонимы арифметических типов (например, std::size_t или std::streamsize) также можно проверять с помощью типовых свойств std::numeric_limits.

Для стандартных типов, не являющихся арифметическими, таких как std::complex<T> или std::nullptr_t, специализации отсутствуют.

Если реализация определяет какие-либо целочисленные типы-классы, для них также должны быть предоставлены специализации std::numeric_limits.

(начиная с C++20)

Реализации могут предоставлять специализации std::numeric_limits для зависящих от реализации типов: например, GCC предоставляет std::numeric_limits<__int128>. Нестандартные библиотеки могут добавлять специализации для предоставляемых библиотекой типов; например, OpenEXR предоставляет std::numeric_limits<half> для 16-битного типа с плавающей точкой.

Параметры шаблона

тип, числовые свойства которого требуется получить

Константы-члены

is_specialized [static]	указывает, для каких типов специализируется `std::numeric_limits` (публичная статическая константа-член)
is_signed [static]	указывает на типы со знаком (публичная статическая константа-член)
is_integer [static]	указывает на целочисленные типы (публичная статическая константа-член)
is_exact [static]	указывает на точные типы (публичная статическая константа-член)
has_infinity [static]	указывает на типы с плавающей точкой, способные представлять специальное значение «положительная бесконечность» (публичная статическая константа-член)
has_quiet_NaN [static]	указывает на типы с плавающей точкой, способные представлять специальное значение «тихое не число» (NaN) (публичная статическая константа-член)
has_signaling_NaN [static]	указывает на типы с плавающей точкой, способные представлять специальное значение «сигнальное не число» (NaN) (публичная статическая константа-член)
has_denorm [static]	указывает на используемый типом с плавающей точкой способ денормализации (публичная статическая константа-член)
has_denorm_loss [static]	указывает на типы с плавающей точкой, которые обнаруживают потерю точности как потерю при денормализации, а не как неточный результат (публичная статическая константа-член)
round_style [static]	указывает на используемый типом способ округления (публичная статическая константа-член)
is_iec559 [static]	указывает на типы с плавающей точкой IEC 559/IEEE 754 (публичная статическая константа-член)
is_bounded [static]	указывает на типы, представляющие конечное множество значений (публичная статическая константа-член)
is_modulo [static]	указывает на типы, обрабатывающие переполнение с помощью модульной арифметики (публичная статическая константа-член)
digits [static]	количество двоичных цифр `radix`, которые можно представить без изменений (публичная статическая константа-член)
digits10 [static]	количество десятичных цифр, которые можно представить без изменений (публичная статическая константа-член)
max_digits10 [static] (C++11)	количество десятичных цифр, необходимое для различения всех значений этого типа (публичная статическая константа-член)
radix [static]	основание системы счисления, используемой для представления данного типа (публичная статическая константа-член)
min_exponent [static]	число, на единицу большее минимальной отрицательной степени основания, являющейся допустимым нормализованным значением с плавающей точкой (публичная статическая константа-член)
min_exponent10 [static]	минимальная отрицательная степень десяти, являющаяся допустимым нормализованным значением с плавающей точкой (публичная статическая константа-член)
max_exponent [static]	число, на единицу большее максимальной целочисленной степени основания, являющейся допустимым конечным значением с плавающей точкой (публичная статическая константа-член)
max_exponent10 [static]	максимальная целочисленная степень десяти, являющаяся допустимым конечным значением с плавающей точкой (публичная статическая константа-член)
traps [static]	указывает на типы, которые могут вызывать аппаратные исключения при арифметических операциях (публичная статическая константа-член)
tinyness_before [static]	указывает на типы с плавающей точкой, которые обнаруживают малость до округления (публичная статическая константа-член)

Функции-члены

min [static]	возвращает наименьшее конечное значение заданного типа без плавающей точки или наименьшее положительное нормализованное значение заданного типа с плавающей точкой (публичная статическая функция-член)
lowest [static] (C++11)	возвращает наименьшее конечное значение заданного типа, то есть наиболее отрицательное значение для типов со знаком, `0` для беззнаковых типов (публичная статическая функция-член)
max [static]	возвращает наибольшее конечное значение заданного типа (публичная статическая функция-член)
epsilon [static]	возвращает разность между `1.0` и следующим представимым значением заданного типа с плавающей точкой (публичная статическая функция-член)
round_error [static]	возвращает максимальную погрешность округления для заданного типа с плавающей точкой (публичная статическая функция-член)
infinity [static]	возвращает значение положительной бесконечности для заданного типа с плавающей точкой (публичная статическая функция-член)
quiet_NaN [static]	возвращает значение тихого NaN для заданного типа с плавающей точкой (публичная статическая функция-член)
signaling_NaN [static]	возвращает значение сигнального NaN для заданного типа с плавающей точкой (публичная статическая функция-член)
denorm_min [static]	возвращает наименьшее положительное субнормальное значение заданного типа с плавающей точкой (публичная статическая функция-член)

Вспомогательные классы

float_round_style	задаёт режимы округления чисел с плавающей точкой (перечисление)
float_denorm_style	задаёт режимы денормализации чисел с плавающей точкой (перечисление)

Связь с макросами-константами библиотеки C

Специализация `std::numeric_limits<T>` где `T` — это	Члены
Специализация `std::numeric_limits<T>` где `T` — это	`min()`	`lowest()` (C++11)	`max()`	`radix`
bool	`false`	`false`	`true`	`2`
char	`CHAR_MIN`	`CHAR_MIN`	`CHAR_MAX`	`2`
signedchar	`SCHAR_MIN`	`SCHAR_MIN`	`SCHAR_MAX`	`2`
unsignedchar	`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`
signedshort	`SHRT_MIN`	`SHRT_MIN`	`SHRT_MAX`	`2`
unsignedshort	`0`	`0`	`USHRT_MAX`	`2`
int	`INT_MIN`	`INT_MIN`	`INT_MAX`	`2`
signedint	`INT_MIN`	`INT_MIN`	`INT_MAX`	`2`
unsignedint	`0`	`0`	`UINT_MAX`	`2`
long	`LONG_MIN`	`LONG_MIN`	`LONG_MAX`	`2`
signedlong	`LONG_MIN`	`LONG_MIN`	`LONG_MAX`	`2`
unsignedlong	`0`	`0`	`ULONG_MAX`	`2`
longlong	`LLONG_MIN`	`LLONG_MIN`	`LLONG_MAX`	`2`
signedlonglong	`LLONG_MIN`	`LLONG_MIN`	`LLONG_MAX`	`2`
unsignedlonglong	`0`	`0`	`ULLONG_MAX`	`2`

Специализация `std::numeric_limits<T>` где `T` — это	Члены
Специализация `std::numeric_limits<T>` где `T` — это	`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`
longdouble	`LDBL_TRUE_MIN`	`LDBL_MIN`	`-LDBL_MAX`	`LDBL_MAX`	`LDBL_EPSILON`	`LDBL_MANT_DIG`	`LDBL_DIG`

Специализация `std::numeric_limits<T>` где `T` — это	Члены (продолжение)
Специализация `std::numeric_limits<T>` где `T` — это	`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`
longdouble	`LDBL_MIN_EXP`	`LDBL_MIN_10_EXP`	`LDBL_MAX_EXP`	`LDBL_MAX_10_EXP`	`FLT_RADIX`

Пример

#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';
}

Возможный вывод:

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

Отчёты об ошибках стандарта

Следующие отчёты об ошибках, изменяющих поведение, были применены ретроспективно к ранее опубликованным стандартам C++.

Отчёт об ошибке	Применён к	Поведение согласно опубликованной версии	Исправленное поведение
LWG 201	C++98	требовалось предоставлять специализации для всех фундаментальных типов	типы, не являющиеся арифметическими, исключены
LWG 559	C++98	не было ясно, ведёт ли себя специализация `std::numeric_limits` для cv-квалифицированного типа так же, как соответствующая специализация для типа без cv-квалификаторов	они ведут себя одинаково

См. также

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/types/numeric_limits