Пространства имён
Варианты
Действия

std::numeric_limits

Материал из cppreference.com
< cpp‎ | types
 
 
Библиотека утилит
Языковая поддержка
Поддержка типов (базовые типы, RTTI)
Макросы тестирования функциональности библиотеки (C++20)    
Управление динамической памятью
Программные утилиты
Поддержка сопрограмм (C++20)
Вариативные функции
Трёхстороннее сравнение (C++20)
(C++20)
(C++20)(C++20)(C++20)(C++20)(C++20)(C++20)
Общие утилиты
Дата и время
Функциональные объекты
Библиотека форматирования (C++20)
(C++11)
Операторы отношения (устарело в C++20)
Целочисленные функции сравнения
(C++20)(C++20)(C++20)    
(C++20)
Операции обмена и типа
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Общие лексические типы
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Элементарные преобразования строк
(C++17)
(C++17)
 
 
 
Определено в заголовочном файле <limits>
template< class T > class numeric_limits;

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

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

Определено в заголовочном файле <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 тип для получения числовых свойств для

[править] Константы-элементы

определяет типы, для которых специализирован std::numeric_limits
(public static константа-элемент) [править]
[static]
определяет знаковые типы
(public static константа-элемент) [править]
[static]
определяет целочисленные типы
(public static константа-элемент) [править]
[static]
определяет точные типы
(public static константа-элемент) [править]
определяет типы с плавающей запятой, которые могут представлять специальное значение "положительная бесконечность"
(public static константа-элемент) [править]
определяет типы с плавающей запятой, которые могут представлять специальное значение "тихое не-число" (NaN - Not-a-Number)
(public static константа-элемент) [править]
определяет типы с плавающей запятой, которые могут представлять специальное значение "сигнальное не-число" (NaN - Not-a-Number)
(public static константа-элемент) [править]
[static]
определяет стиль денормализации, используемый типом с плавающей запятой
(public static константа-элемент) [править]
определяет типы с плавающей запятой, которые обнаруживают потерю точности как потерю денормализации, а не неточный результат
(public static константа-элемент) [править]
[static]
определяет стиль округления, используемый типом
(public static константа-элемент) [править]
[static]
определяет типы с плавающей точкой IEC 559/IEEE 754
(public static константа-элемент) [править]
[static]
определяет типы, представляющие конечный набор значений
(public static константа-элемент) [править]
[static]
определяет типы, которые обрабатывают переполнения с арифметикой по модулю
(public static константа-элемент) [править]
[static]
количество цифр системы счисления, которые могут быть представлены без изменений
(public static константа-элемент) [править]
[static]
количество десятичных цифр, которые могут быть представлены без изменений
(public static константа-элемент) [править]
[static] (C++11)
количество десятичных цифр, необходимое для различения всех значений этого типа
(public static константа-элемент) [править]
[static]
основание системы счисления или целочисленное основание, используемое представлением данного типа
(public static константа-элемент) [править]
на единицу больше, чем наименьшая отрицательная степень системы счисления, которая является допустимым нормализованным значением с плавающей запятой
(public static константа-элемент) [править]
наименьшая отрицательная степень десяти, которая является допустимым нормализованным значением с плавающей запятой
(public static константа-элемент) [править]
на единицу больше, чем наибольшая целая степень системы счисления, которая является допустимым конечным значением с плавающей запятой
(public static константа-элемент) [править]
наибольшее целое число в степени 10, которое является допустимым конечным значением с плавающей запятой
(public static константа-элемент) [править]
[static]
определяет типы, которые могут вызывать перехват арифметических операций
(public static константа-элемент) [править]
определяет типы с плавающей запятой, которые обнаруживают крошечную величину перед округлением
(public static константа-элемент) [править]

[править] Функции-элементы

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

[править] Вспомогательные классы

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

[править] Связь с макроконстантами библиотеки 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-квалификации
у них такое же поведение

[прав��ть] Смотрите также