std::numeric_limits

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Языковая поддержка Поддержка типов (базовые типы, RTTI) Макросы тестирования функциональности библиотеки (C++20)     Управление динамической памятью Программные утилиты Поддержка сопрограмм (C++20) Вариативные функции is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Трёхстороннее сравнение (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)     is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

Общие утилиты Дата и время Функциональные объекты Библиотека форматирования (C++20) bitset hash (C++11) Операторы отношения (устарело в C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Целочисленные функции сравнения cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)     cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Операции обмена и типа swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Общие лексические типы pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Элементарные преобразования строк to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

Поддержка типов

Базовые типы
Целочисленные типы фиксированной ширины (C++11)
Типы с плавающей запятой фиксированной ширины (C++23)
ptrdiff_t size_t max_align_t (C++11)     byte (C++17)	nullptr_t (C++11) offsetof NULL
Числовые ограничения
numeric_limits
Интерфейс числовых ограничений C
Информация о типе времени выполнения
type_info type_index (C++11)	bad_typeid bad_cast

 

std::numeric_limits

Статические константы

numeric_limits::is_specialized

numeric_limits::is_signed

numeric_limits::is_integer

numeric_limits::is_exact

numeric_limits::has_infinity

numeric_limits::has_quiet_NaN

numeric_limits::has_signaling_NaN

numeric_limits::has_denorm

numeric_limits::has_denorm_loss

numeric_limits::round_style

numeric_limits::is_iec559

numeric_limits::is_bounded

numeric_limits::is_modulo

numeric_limits::digits

numeric_limits::digits10

numeric_limits::max_digits10 (C++11)

numeric_limits::radix

numeric_limits::min_exponent

numeric_limits::min_exponent10

numeric_limits::max_exponent

numeric_limits::max_exponent10

numeric_limits::traps

numeric_limits::tinyness_before

Статические функции-элементы

numeric_limits::min

numeric_limits::lowest (C++11)

numeric_limits::max

numeric_limits::epsilon

numeric_limits::round_error

numeric_limits::infinity

numeric_limits::quiet_NaN

numeric_limits::signaling_NaN

numeric_limits::denorm_min

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

float_round_style

float_denorm_style

 

<tbody> </tbody>

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

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

Эта информация предоставляется через специализации шаблона numeric_limits. В стандартной библиотеке доступны специализации для всех арифметических типов:

<tbody> </tbody>

Определено в заголовочном файле <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>;

Также предусмотрены специализации для всех типов целочисленных классов.

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

Значение каждого элемента специализации 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-битного типа с плавающей запятой.

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

T

—

тип для получения числовых свойств для

Константы-элементы

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

Функции-элементы

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

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

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

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

Специализация
	Специализация 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
unsigned short	0	0	USHRT_MAX	2
int	INT_MIN	INT_MIN	INT_MAX	2
signed int
unsigned int	0	0	UINT_MAX	2
long	LONG_MIN	LONG_MIN	LONG_MAX	2
signed long
unsigned long	0	0	ULONG_MAX	2
long long	LLONG_MIN	LLONG_MIN	LLONG_MAX	2
signed long long
unsigned long long	0	0	ULLONG_MAX	2

Специализация 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 это	Элементы (продолжение)
	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 <limits>
#include <iostream>
 
int main() 
{
    std::cout 
         << "тип\t│ lowest()\t│ min()\t\t│ max()\n\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';
}

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

тип	│ 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-квалификации	у них такое же поведение

Смотрите также

• Целочисленные типы фиксированной ширины
• Арифметические типы
• Обзор системы типов C++
• Поддержка типов (базовые типы, RTTI, свойства типов)
• Интерфейс числовых ограничений C