Numeric limits c что это

Numeric limits c что это

Определяет шаблон numeric_limits класса и два перечисления, касающиеся представлений с плавающей запятой и округления.

Требования

Заголовок:

Пространство имен: std

Замечания

Явные специализации класса numeric_limits описывают множество свойств базовых типов, включая включая символьные типа, целочисленные типы, типы с плавающей запятой и bool , определяемые реализацией, а не фиксированными правилами языка C++. Свойства, описанные в , включают точность, минимальное и максимальное представление размеров, округление и сигнальные ошибки типа.

Участники

Перечисления

Имя	Описание
float_denorm_style	Перечисление описывает различные методы, которые могут быть выбраны реализацией для представления ненормализованного значения с плавающей запятой, если оно мало для представления в качестве нормализованного значения:
float_round_style	Перечисление описывает различные методы, которые могут быть выбраны реализацией для округления значения с плавающей запятой до целочисленного.

Классы

Имя	Описание
numeric_limits Class	Шаблон класса описывает арифметические свойства встроенных числовых типов.

Класс numeric_limits

Шаблон класса описывает арифметические свойства встроенных числовых типов.

Синтаксис

template class numeric_limits 

Параметры

Тип
Базовый тип данных элемента, свойства которого проверяются, запрашиваются или устанавливаются. Тип также можно объявить const или volatile const volatile .

Замечания

Заголовок определяет явные специализации для типов wchar_t , long double bool int unsigned short unsigned int short long unsigned char unsigned long float signed char char long long unsigned long long double char16_t и . char32_t Для этих явных специализаций член numeric_limits::is_specialized является true , а все соответствующие элементы имеют значимые значения. Программа может предоставлять дополнительные явные специализации. Большинство функций — членов класса описывают или проверяют возможные реализации float .

Для произвольной специализации у членов нет значимых значений. Объект-член, у которого нет значимых значений, сохраняет ноль (или false ), а функция-член, не возвращающая значимое значение, возвращает Type(0) .

Статические функции и константы

Имя	Описание
denorm_min	Возвращает наименьшее ненулевое денормализованное значение.
digits	Возвращает количество цифр основания системы счисления, которое тип может представлять без потери точности.
digits10	Возвращает количество дробных десятичных цифр, которое тип может представлять без потери точности.
epsilon	Возвращает разницу между 1 и наименьшим значением больше 1, которое этот тип данных может представлять.
has_denorm	Проверяет, допускает ли тип денормализованные значения.
has_denorm_loss	Проверяет, обнаружена ли потеря точности как потеря денормализации, а не неточный результат.
has_infinity	Проверяет, может ли тип представлять положительную бесконечность.
has_quiet_NaN	Проверяет, имеет ли тип представление для тихого не числа (NAN), который не сигнализирует.
has_signaling_NaN	Проверяет, может ли тип представлять сообщения об обнаружении нечисла (NAN).
infinity	Представление положительной бесконечности для типа, если доступно.
is_bounded	Проверяет, конечен ли набор значений, представляемый типом.
is_exact	Проверяет, не содержат ли вычисления с типом ошибок округления.
is_iec559	Проверяет, соответствует ли тип стандартам IEC 559.
is_integer	Проверяет, может ли тип представлять целые числа.
is_modulo	Проверяет, может ли тип представлять модуль.
is_signed	Проверяет, может ли тип представлять числа со знаком.
is_specialized	Проверяет, имеет ли тип явную специализацию, определенную в шаблоне numeric_limits класса.
lowest	Возвращает наибольшее отрицательное конечное значение.
max	Возвращает максимальное конечное значение типа.
max_digits10	Возвращает количество цифр дробной части, необходимых, чтобы у двух различных значений типа были уникальные десятичные представления.
max_exponent	Возвращает максимальную положительную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении основания системы счисления в эту степень.
max_exponent10	Возвращает максимальную положительную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении десяти в эту степень.
min	Возвращает минимальное нормализованное значение для типа.
min_exponent	Возвращает максимальную отрицательную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении основания системы счисления в эту степень.
min_exponent10	Возвращает максимальную отрицательную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении десяти в эту степень.
quiet_NaN	Возвращает представление «тихого» нечисла (NAN) для типа.
radix	Возвращает целочисленное основание системы счисления, используемое для представления типа.
round_error	Возвращает максимальную ошибку округления для типа.
round_style	Возвращает значение, описывающее различные методы, которые могут быть выбраны реализацией для округления значения с плавающей запятой до целочисленного.
signaling_NaN	Возвращает представление обозначения нечисла (NAN) для типа.
tinyness_before	Проверяет, может ли тип определить, что значение слишком мало для представления в качестве нормализованного значения, до его округления.
traps	Проверяет, реализованы ли для типа исключения при выполнении арифметических операций.

denorm_min

Возвращает наименьшее ненулевое денормализованное значение.

static constexpr Type denorm_min() throw(); 

Возвращаемое значение

Наименьшее ненулевое денормализованное значение.

Замечания

long double совпадает с double компилятором C++.

Пример

// numeric_limits_denorm_min.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::denorm_min( ) ::denorm_min( ) ::denorm_min( ) ::denorm_min( )/2 ::denorm_min( )/2 ::denorm_min( )/2

The smallest nonzero denormalized value for float objects is: 1.4013e-045 The smallest nonzero denormalized value for double objects is: 4.94066e-324 The smallest nonzero denormalized value for long double objects is: 4.94066e-324 0 0 0 

digits

Возвращает количество цифр основания системы счисления, которое тип может представлять без потери точности.

static constexpr int digits = 0; 

Возвращаемое значение

Количество цифр основания системы счисления, которое тип может представлять без потери точности.

Замечания

Член сохраняет количество цифр основания системы счисления, которое тип может представлять без изменения, то есть количество бит (кроме бита знака) для предопределенного целочисленного типа, либо количество цифр мантиссы для предопределенного типа числа с плавающей запятой.

Пример

// numeric_limits_digits_min.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::digits ::digits ::digits ::digits ::digits

24 53 53 31 63 

digits10

Возвращает количество дробных десятичных цифр, которое тип может представлять без потери точности.

static constexpr int digits10 = 0; 

Возвращаемое значение

Количество дробных десятичных цифр, которое тип может представлять без потери точности.

Пример

// numeric_limits_digits10.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::digits10 ::digits10 ::digits10 ::digits10 ::digits10

6 15 15 9 18 The float is; 100000000 

epsilon

Функция возвращает разницу между 1 и наименьшим значением больше 1, которое может быть представлено для типа данных.

static constexpr Type epsilon() throw(); 

Возвращаемое значение

Разница между 1 и наименьшим значением больше 1, которое может быть представлено для типа данных.

Замечания

Значение FLT_EPSILON для типа float . epsilon для типа — это наименьшее положительное число с плавающей запятой N, так что N + epsilon + N можно представить.

Пример

// numeric_limits_epsilon.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::epsilon( ) ::epsilon( ) ::epsilon( )

The difference between 1 and the smallest value greater than 1 for float objects is: 1.19209e-007 The difference between 1 and the smallest value greater than 1 for double objects is: 2.22045e-016 The difference between 1 and the smallest value greater than 1 for long double objects is: 2.22045e-016 

has_denorm

Проверяет, допускает ли тип денормализованные значения.

static constexpr float_denorm_style has_denorm = denorm_absent; 

Возвращаемое значение

Значение перечисления типа const float_denorm_style , указывающее, допускает ли тип денормализованные значения.

Замечания

Член хранит denorm_present тип с плавающей запятой, имеющий денормализованные значения, фактически переменное число экспонентных битов.

Пример

// numeric_limits_has_denorm.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::has_denorm ::has_denorm ::has_denorm

Whether float objects allow denormalized values: 1 Whether double objects allow denormalized values: 1 Whether long int objects allow denormalized values: 0 

has_denorm_loss

Проверяет, обнаружена ли потеря точности как потеря денормализации, а не неточный результат.

static constexpr bool has_denorm_loss = false; 

Возвращаемое значение

true Значение , если потеря точности обнаружена как потеря денормализации; false Если нет.

Замечания

Член сохраняет значение true для типа, который определяет была ли потеря точности связана с представлением в виде денормализованного результата (слишком маленькое для представления в виде нормализованного значения) или поскольку оно неточное (отличается от результата, не подверженного ограничениям диапазона экспоненты и точности), опция с представлениями IEC 559 с плавающей точкой, которые могут повлиять не некоторые результаты.

Пример

// numeric_limits_has_denorm_loss.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::has_denorm_loss ::has_denorm_loss ::has_denorm_loss

Whether float objects can detect denormalized loss: 1 Whether double objects can detect denormalized loss: 1 Whether long int objects can detect denormalized loss: 0 

has_infinity

Проверяет, может ли тип представлять положительную бесконечность.

static constexpr bool has_infinity = false; 

Возвращаемое значение

true Значение , если тип имеет представление для положительной бесконечности; false Если нет.

Замечания

Элемент возвращается true , если is_iec559 true .

Пример

// numeric_limits_has_infinity.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::has_infinity ::has_infinity ::has_infinity

Whether float objects have infinity: 1 Whether double objects have infinity: 1 Whether long int objects have infinity: 0 

has_quiet_NaN

Проверяет, может ли тип представлять "тихое" нечисло (NAN), которое является несигнализирующим.

static constexpr bool has_quiet_NaN = false; 

Возвращаемое значение

true Значение , если тип имеет представление для тихой NAN; false если нет.

Замечания

"Тихое" NAN — это кодирование для нечисла, которое не обозначает свое присутствие в выражении. Возвращаемое значение имеет true значение, если is_iec559 имеет значение true.

Пример

// numeric_limits_has_quiet_nan.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::has_quiet_NaN ::has_quiet_NaN ::has_quiet_NaN

Whether float objects have quiet_NaN: 1 Whether double objects have quiet_NaN: 1 Whether long int objects have quiet_NaN: 0 

has_signaling_NaN

Проверяет, может ли тип представлять сообщения об обнаружении нечисла (NAN).

static constexpr bool has_signaling_NaN = false; 

Возвращаемое значение

true Значение , если тип имеет представление для сигнального NAN; false Если нет.

Замечания

Сообщение о нечисле — это кодирование для нечисла, которое сообщает о его присутствии в выражении. Возвращаемое значение имеет true значение, если is_iec559 имеет значение true.

Пример

// numeric_limits_has_signaling_nan.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::has_signaling_NaN ::has_signaling_NaN ::has_signaling_NaN

Whether float objects have a signaling_NaN: 1 Whether double objects have a signaling_NaN: 1 Whether long int objects have a signaling_NaN: 0 

infinity

Представление положительной бесконечности для типа, если имеется.

static constexpr Type infinity() throw(); 

Возвращаемое значение

Представление положительной бесконечности для типа, если имеется.

Замечания

Возвращаемое значение имеет смысл только в том случае, если has_infinity true .

Пример

// numeric_limits_infinity.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::has_infinity ::has_infinity::has_infinity ::has_infinity ::has_infinity <
1 1 1 0 0 The representation of infinity for type float is: inf The representation of infinity for type double is: inf The representation of infinity for type long double is: inf 
is_bounded
Проверяет, конечен ли набор значений, представляемый типом.
static constexpr bool is_bounded = false; 
Возвращаемое значение
 true Значение , если тип имеет ограниченный набор представленных значений; false Если нет.
Замечания
Все предопределенные типы имеют ограниченный набор представленных значений и возвращаемых true значений.
Пример
// numeric_limits_is_bounded.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_bounded ::is_bounded ::is_bounded ::is_bounded
Whether float objects have bounded set of representable values: 1 Whether double objects have bounded set of representable values: 1 Whether long int objects have bounded set of representable values: 1 Whether unsigned char objects have bounded set of representable values: 1 
is_exact
Проверяет, не содержат ли вычисления с типом ошибок округления.
static constexpr bool is_exact = false; 
Возвращаемое значение
 true Значение , если вычисления не имеют ошибок округления; false Если нет.
Замечания
Все предопределенные типы целых чисел имеют точное представление для их значений и возвращаемых false значений. Вещественное представление или представление с фиксированной запятой также считается точным, но представление с плавающей точкой — нет.
Пример
// numeric_limits_is_exact.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_exact ::is_exact ::is_exact ::is_exact
Whether float objects have calculations free of rounding errors: 0 Whether double objects have calculations free of rounding errors: 0 Whether long int objects have calculations free of rounding errors: 1 Whether unsigned char objects have calculations free of rounding errors: 1 
is_iec559
Проверяет, соответствует ли тип стандартам IEC 559.
static constexpr bool is_iec559 = false; 
Возвращаемое значение
 true , если тип соответствует стандартам IEC 559; false Если нет.
Замечания
IEC 559 — это международный стандарт для представления значений с плавающей точкой, который также известен в США как IEEE 754.
Пример
// numeric_limits_is_iec559.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_iec559 ::is_iec559 ::is_iec559 ::is_iec559
Whether float objects conform to iec559 standards: 1 Whether double objects conform to iec559 standards: 1 Whether int objects conform to iec559 standards: 0 Whether unsigned char objects conform to iec559 standards: 0 
is_integer
Проверяет, может ли тип представлять целые числа.
static constexpr bool is_integer = false; 
Возвращаемое значение
 true Значение , если тип имеет целочисленное представление; false Если нет.
Замечания
Все предопределенные целочисленные типы могут представлять целые числа.
Пример
// numeric_limits_is_integer.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_integer ::is_integer ::is_integer ::is_integer
Whether float objects have an integral representation: 0 Whether double objects have an integral representation: 0 Whether int objects have an integral representation: 1 Whether unsigned char objects have an integral representation: 1 
is_modulo
Проверяет, имеет ли тип type представление по модулю.
static constexpr bool is_modulo = false; 
Возвращаемое значение
 true Значение , если тип имеет представление в модуле; false Если нет.
Замечания
Представление по модулю — это представление, в котором все результаты уменьшены по модулю на некоторое значение. Все предопределенные целочисленные беззнаковые типы имеют представление по модулю.
Пример
// numeric_limits_is_modulo.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_modulo ::is_modulo ::is_modulo ::is_modulo
Whether float objects have a modulo representation: 0 Whether double objects have a modulo representation: 0 Whether signed char objects have a modulo representation: 1 Whether unsigned char objects have a modulo representation: 1 
is_signed
Проверяет, может ли тип представлять числа со знаком.
static constexpr bool is_signed = false; 
Возвращаемое значение
 true Значение , если тип имеет подписанное представление; false Если нет.
Замечания
Член хранит значение true для типа, который может представлять числа со знаком, что верно для всех предопределенных типов с плавающей точкой и целочисленных типов со знаком.
Пример
// numeric_limits_is_signaled.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_signed ::is_signed ::is_signed ::is_signed
Whether float objects have a signed representation: 1 Whether double objects have a signed representation: 1 Whether signed char objects have a signed representation: 1 Whether unsigned char objects have a signed representation: 0 
is_specialized
Проверяет, имеет ли тип явную специализацию, определенную в шаблоне numeric_limits класса.
static constexpr bool is_specialized = false; 
Возвращаемое значение
 true Значение , если тип имеет явную специализацию, определенную в шаблоне класса; false Если нет.
Замечания
Все скалярные типы, отличные от указателей, имеют явную специализацию, определенную для шаблона numeric_limits класса.
Пример
// numeric_limits_is_specialized.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::is_specialized ::is_specialized ::is_specialized ::is_specialized
Whether float objects have an explicit specialization in the class: 1 Whether float* objects have an explicit specialization in the class: 0 Whether int objects have an explicit specialization in the class: 1 Whether int* objects have an explicit specialization in the class: 0 
самый низкий
Возвращает наибольшее отрицательное конечное значение.
static constexpr Type lowest() throw(); 
Возвращаемое значение
Возвращает наибольшее отрицательное конечное значение.
Замечания
Возвращает наиболее отрицательное конечное значение для типа (для целочисленных типов это обычно min() , а для типов с плавающей точкой — -max() ). Возвращаемое значение является содержательным, если is_bounded имеет значение true .
max
Возвращает максимальное конечное значение типа.
static constexpr Type max() throw(); 
Возвращаемое значение
Максимальное конечное значение для типа.
Замечания
Максимальное конечное значение — INT_MAX для типа и FLT_MAX для типа int float . Возвращаемое значение имеет смысл, если is_bounded true .
Пример
// numeric_limits_max.cpp // compile with: /EHsc #include #include using namespace std; int main() < cout ::max( ) ::max( ) ::max( ) ::max( )
max_digits10
Возвращает количество цифр дробной части, необходимых, чтобы у двух различных значений типа были уникальные десятичные представления.
static constexpr int max_digits10 = 0; 
Возвращаемое значение
Возвращает количество цифр дробной части, необходимых, чтобы у двух различных значений типа были уникальные десятичные представления.
Замечания
Этот член хранит количество цифр дробной части, необходимых, чтобы у двух различных значений типа были уникальные десятичные представления.
max_exponent
Возвращает максимальную положительную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении основания системы счисления в эту степень.
static constexpr int max_exponent = 0; 
Возвращаемое значение
Максимальная целочисленная степень для основания системы счисления, представляемая типом.
Замечания
Возвращаемое значение функции-члена имеет смысл только для типов с плавающей запятой. Это max_exponent значение, FLT_MAX_EXP для типа float .
Пример
// numeric_limits_max_exponent.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::max_exponent ::max_exponent ::max_exponent
The maximum radix-based exponent for type float is: 128 The maximum radix-based exponent for type double is: 1024 The maximum radix-based exponent for type long double is: 1024 
max_exponent10
Возвращает максимальную положительную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении десяти в эту степень.
static constexpr int max_exponent10 = 0; 
Возвращаемое значение
Максимальная целочисленная степень основания 10, которую может представить этот тип.
Замечания
Возвращаемое значение функции-члена имеет смысл только для типов с плавающей запятой. Значение max_exponent FLT_MAX_10 для типа float .
Пример
// numeric_limits_max_exponent10.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::max_exponent10 ::max_exponent10 ::max_exponent10
The maximum base 10 exponent for type float is: 38 The maximum base 10 exponent for type double is: 308 The maximum base 10 exponent for type long double is: 308 
мин
Возвращает минимальное нормализованное значение для типа.
static constexpr Type min() throw(); 
Возвращаемое значение
Минимальное нормализованное значение для типа.
Замечания
Минимальное нормализованное значение для типа int — INT_MIN, а для типа float — FLT_MIN. Возвращаемое значение имеет смысл, если is_bounded имеет значение true или is_signed имеет значение false .
Пример
// numeric_limits_min.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::min( ) ::min( ) ::min( ) ::min( )
The minimum value for type float is: 1.17549e-038 The minimum value for type double is: 2.22507e-308 The minimum value for type int is: -2147483648 The minimum value for type short int is: -32768 
min_exponent
Возвращает максимальную отрицательную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении основания системы счисления в эту степень.
static constexpr int min_exponent = 0; 
Возвращаемое значение
Минимальная целочисленная степень основания системы счисления, которую может представить тип.
Замечания
Функция-член имеет смысл только для типов с плавающей запятой. Значение min_exponent FLT_MIN_EXP для типа float .
Пример
// numeric_limits_min_exponent.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::min_exponent ::min_exponent ::min_exponent
The minimum radix-based exponent for type float is: -125 The minimum radix-based exponent for type double is: -1021 The minimum radix-based exponent for type long double is: -1021 
min_exponent10
Возвращает максимальную отрицательную целую степень, которую тип с плавающей запятой может представить как конечное значение при возведении десяти в эту степень.
static constexpr int min_exponent10 = 0; 
Возвращаемое значение
Минимальная целая степень числа 10, которую может представить тип.
Замечания
Функция-член имеет смысл только для типов с плавающей запятой. Значение min_exponent10 FLT_MIN_10_EXP для типа float .
Пример
// numeric_limits_min_exponent10.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::min_exponent10 ::min_exponent10 ::min_exponent10
The minimum base 10 exponent for type float is: -37 The minimum base 10 exponent for type double is: -307 The minimum base 10 exponent for type long double is: -307 
quiet_NaN
Возвращает представление "тихого" нечисла (NAN) для типа.
static constexpr Type quiet_NaN() throw(); 
Возвращаемое значение
Представление "тихого" нечисла (NAN) для типа.
Замечания
Возвращаемое значение имеет смысл только в том случае, если has_quiet_NaN true  .
Пример
// numeric_limits_quiet_nan.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::quiet_NaN( ) ::quiet_NaN( ) ::quiet_NaN( )
The quiet NaN for type float is: 1.#QNAN The quiet NaN for type int is: 0 The quiet NaN for type long double is: 1.#QNAN 
radix
Возвращает целочисленное основание системы счисления, используемое для представления типа.
static constexpr int radix = 0; 
Возвращаемое значение
Целочисленная база для представления типа.
Замечания
Для предопределенных целочисленных типов база — 2, а для предопределенных типов с плавающей запятой — база, в которую можно возвести степень, или FLT_RADIX.
Пример
// numeric_limits_radix.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::radix ::radix ::radix
The base for type float is: 2 The base for type int is: 2 The base for type long double is: 2 
round_error
Возвращает максимальную ошибку округления для типа.
static constexpr Type round_error() throw(); 
Возвращаемое значение
Максимальная ошибка округления для типа.
Пример
// numeric_limits_round_error.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::round_error( ) ::round_error( ) ::round_error( )
The maximum rounding error for type float is: 0.5 The maximum rounding error for type int is: 0 The maximum rounding error for type long double is: 0.5 
round_style
Возвращает значение, описывающее различные методы, которые могут быть выбраны реализацией для округления значения с плавающей запятой до целочисленного.
static constexpr float_round_style round_style = round_toward_zero; 
Возвращаемое значение
Значение из перечисления float_round_style , которое описывает тип округления.
Замечания
Член хранит значение, которое описывает различные методы, из которых реализация может выбирать для округления значения с плавающей точкой до целого значения.
Метод округления жестко закодирован в реализации, поэтому даже если программа запускается с другим методом округления, это значение не изменится.
Пример
// numeric_limits_round_style.cpp // compile with: /EHsc #include #include #include using namespace std; int main( ) < cout ::round_style ::round_style ::round_style
The rounding style for a double type is: 1 The rounding style for a double type is now: 1 The rounding style for an int type is: 0 
signaling_NaN
Возвращает представление обозначения нечисла (NAN) для типа.
static constexpr Type signaling_NaN() throw(); 
Возвращаемое значение
Представление сообщения о нечисле (NAN) для типа.
Замечания
Возвращаемое значение имеет смысл только в том случае, если has_signaling_NaN true  .
Пример
// numeric_limits_signaling_nan.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::signaling_NaN( ) ::signaling_NaN( ) ::signaling_NaN( )
tinyness_before
Проверяет, может ли тип определить, что значение слишком мало для представления в качестве нормализованного значения, до его округления.
static constexpr bool tinyness_before = false; 
Возвращаемое значение
 true , если тип перед округлением может определить, что значение слишком мало; в противном случае false .
Замечания
Типы, которые могут распознавать слишком малые значения, были включены в представления IEC 559 с плавающей запятой в качестве опции и их реализация может влиять на некоторые результаты.
Пример
// numeric_limits_tinyness_before.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::tinyness_before ::tinyness_before ::tinyness_before ::tinyness_before
Whether float types can detect tinyness before rounding: 1 Whether double types can detect tinyness before rounding: 1 Whether long int types can detect tinyness before rounding: 0 Whether unsigned char types can detect tinyness before rounding: 0 
traps
Проверяет, реализованы ли для типа исключения при выполнении арифметических операций.
static constexpr bool traps = false; 
Возвращаемое значение
 true Значение , если перехват реализуется для типа; false Если это не так.
Пример
// numeric_limits_traps.cpp // compile with: /EHsc #include #include using namespace std; int main( ) < cout ::traps ::traps ::traps ::traps
Whether float types have implemented trapping: 1 Whether double types have implemented trapping: 1 Whether long int types have implemented trapping: 0 Whether unsigned char types have implemented trapping: 0 
Numeric limits c что это
На этом шаге мы рассмотрим пример использования класса numeric_limits .
Следующий пример демонстрирует использование числовых пределов. Он выводит максимальные возможные значения некоторых типов, а также проверяет, является ли тип char знаковым.
//--------------------------------------------------------------------------- #include #include #include #include #include //необходимо для getch() #pragma hdrstop //--------------------------------------------------------------------------- #pragma argsused using namespace std; int main(int argc, char* argv[]) < // Использование текстового представления для bool cout // Вывод максимальных значений для целочисленных типов cout ::max() int): " ::max() long): " ::max() // Вывод максимальных значений для вещественных типов cout float): " ::max() double): " ::max() // Проверяем, является ли тип char знаковым. cout char): " ::is_signed // Проверка наличия числовых пределов у типа string cout << "is_specialized(string): " << numeric_limits::is_specialized return 0; > //--------------------------------------------------------------------------- 
Текст этого примера можно взять здесь.
Результат выполнения программы зависит от платформы. Один из возможных вариантов выглядит так:
Рис.1. Результат работы приложения
Последняя строка означает, что для типа string числовые пределы не поддерживаются. Впрочем, это вполне логично, поскольку строки не являются числовыми величинами. Однако приведенный пример наглядно показывает, что программист может обратиться с запросом к любому типу и узнать, поддерживает ли он числовые пределы.
Со следующего шага мы начнем рассматривать вспомогательные функции .
std:: numeric_limits
The std::numeric_limits class template provides a standardized way to query various properties of arithmetic types (e.g. the largest possible value for type int is std :: numeric_limits < int >:: max ( ) ).
This information is provided via specializations of the std::numeric_limits template. The standard library makes available specializations for all arithmetic types (only lists the specializations for cv-unqualified arithmetic types):
Defined in header

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 >;

template <> class numeric_limits < char16_t >;

template <> class numeric_limits < char32_t >;

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 >;

template <> class numeric_limits < unsigned long long >;

template <> class numeric_limits < float >;

template <> class numeric_limits < double >;

template <> class numeric_limits < long double >;
The value of each member of a specialization of std::numeric_limits on a cv-qualified type cv T is equal to the value of the corresponding member of the specialization on the unqualified type T . For example, std :: numeric_limits < int >:: digits is equal to std :: numeric_limits < const int >:: digits .
Aliases of arithmetic types (such as std::size_t or std::streamsize ) may also be examined with the std::numeric_limits type traits.
Non-arithmetic standard types, such as std:: complex < T >or std::nullptr_t , do not have specializations.
If the implementation defines any integer-class types, specializations of std::numeric_limits must also be provided for them.
Implementations may provide specializations of std::numeric_limits for implementation-specific types: e.g. GCC provides std::numeric_limits . Non-standard libraries may add specializations for library-provided types, e.g. OpenEXR provides std::numeric_limits for a 16-bit floating-point type.
Contents

1 Template parameters
2 Member constants
3 Member functions
4 Helper classes
5 Relationship with C library macro constants
6 Example
7 Defect reports
8 See also

[edit] Template parameters


T
-
a type to retrieve numeric properties for


[edit] Member constants
[static] (C++11)
[edit] Member functions
[static] (C++11)
[edit] Helper classes
[edit] Relationship with C library macro constants


Specialization 
std::numeric_limits 
where T is
Members


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




Specialization 
std::numeric_limits 
where T is
Members


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 




Specialization 
std::numeric_limits 
where T is
Members (continue)


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 


[edit] Example
Run this code
#include #include int main() { std::cout  "type\t│ lowest()\t│ min()\t\t│ max()\n"  "bool\t│ "  std::numeric_limitsbool>::lowest()  "\t\t│ "  std::numeric_limitsbool>::min()  "\t\t│ "  std::numeric_limitsbool>::max()  '\n'  "uchar\t│ "  +std::numeric_limitsunsigned char>::lowest()  "\t\t│ "  +std::numeric_limitsunsigned char>::min()  "\t\t│ "  +std::numeric_limitsunsigned char>::max()  '\n'  "int\t│ "  std::numeric_limitsint>::lowest()  "\t│ "  std::numeric_limitsint>::min()  "\t│ "  std::numeric_limitsint>::max()  '\n'  "float\t│ "  std::numeric_limitsfloat>::lowest()  "\t│ "  std::numeric_limitsfloat>::min()  "\t│ "  std::numeric_limitsfloat>::max()  '\n'  "double\t│ "  std::numeric_limitsdouble>::lowest()  "\t│ "  std::numeric_limitsdouble>::min()  "\t│ "  std::numeric_limitsdouble>::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
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.


DR
Applied to
Behavior as published
Correct behavior


LWG 201 
C++98
specializations for all fundamental types need to be provided
excluded non-arithmetic types


LWG 559 
C++98
it was unclear whether the std::numeric_limits 
specialization for a cv-qualified type behaves as the same as
the corresponding specialization for the cv-unqualified type
they have the
same behavior


[edit] See also

Fixed width integer types
Arithmetic types
C++ type system overview
Type support (basic types, RTTI, type traits)
C numeric limits interface



Похожие публикации:

Eac и global version в чем разница
В какой последовательности изучать языки программирования
Как почистить компьютер от ненужных программ и файлов
Как сделать плинтус в архикаде