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]	количество значащих цифр, которые могут быть представлены без изменений (публичная статическая константа-член)
digits10 [static]	количество десятичных цифр, которые могут быть представлены без изменений (публичная статическая константа-член)
max_digits10 [static] (C++11)	количество десятичных цифр, необходимых для различения всех значений данного типа (публичная статическая константа-член)
radix [static]	основание или целое основание, используемое для представления данного типа (публичная статическая константа-член)
min_exponent [static]	на единицу больше наименьшей отрицательной степени основания, являющейся допустимым нормализованным значением с плавающей точкой (публичная статическая константа-член)
min_exponent10 [static]	наименьшая отрицательная степень десяти, которая является допустимым нормализованным значением с плавающей точкой (публичная статическая константа-член)
max_exponent [static]	на единицу больше наибольшей целой степени основания, которая является допустимым конечным значением с плавающей точкой (публичная статическая константа-член)
max_exponent10 [static]	наибольшая целая степень 10, которая является допустимым конечным значением с плавающей точкой (публичная статическая константа-член)
traps [static]	определяет типы, которые могут вызывать ловушки при арифметических операциях (публичная статическая константа-член)
tinyness_before [static]	определяет типы с плавающей точкой, которые обнаруживают малость до округления (публичная статическая константа-член)

Члены-функции

min [static]	возвращает наименьшее конечное значение заданного типа (публичный статический член-функция)
lowest [static] (C++11)	возвращает наименьшее конечное значение заданного типа (публичный статический член-функция)
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`
signed char	`SCHAR_MIN`	`SCHAR_MIN`	`SCHAR_MAX`	`2`
unsigned char	`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`
signed short	`SHRT_MIN`	`SHRT_MIN`	`SHRT_MAX`	`2`
unsigned short	`0`	`0`	`USHRT_MAX`	`2`
int	`INT_MIN`	`INT_MIN`	`INT_MAX`	`2`
signed int	`INT_MIN`	`INT_MIN`	`INT_MAX`	`2`
unsigned int	`0`	`0`	`UINT_MAX`	`2`
long	`LONG_MIN`	`LONG_MIN`	`LONG_MAX`	`2`
signed long	`LONG_MIN`	`LONG_MIN`	`LONG_MAX`	`2`
unsigned long	`0`	`0`	`ULONG_MAX`	`2`
long long	`LLONG_MIN`	`LLONG_MIN`	`LLONG_MAX`	`2`
signed long long	`LLONG_MIN`	`LLONG_MIN`	`LLONG_MAX`	`2`
unsigned long long	`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`
long double	`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`
long double	`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++.

DR	Применено к	Поведение при публикации	Корректное поведение
LWG 201	C++98	специализации для всех фундаментальных типов должны быть предоставлены	исключены неарифметические типы
LWG 559	C++98	не было ясно, ведет ли специализация для cv-квалифицированного типа себя так же, как и соответствующая специализация для cv-неквалифицированного типа	они имеют одинаковое поведение

См. также

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