Класс numeric_limits

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

Синтаксис

template <class Type>
    class numeric_limits

Параметры

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

Замечания

Заголовок определяет явные специализации для типов wchar_t, long doubleboolintunsigned shortunsigned intshortlongunsigned charunsigned longfloatsigned charcharlong longunsigned long longdoublechar16_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++.

Функция возвращает минимальное значение для типа, которое совпадает с минимальной, если has_denorm не равноdenorm_present.

Пример

// numeric_limits_denorm_min.cpp
// compile with: /EHsc
#include <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The smallest nonzero denormalized value" << endl
        << "for float objects is: "
        << numeric_limits<float>::denorm_min( ) << endl;
   cout << "The smallest nonzero denormalized value" << endl
        << "for double objects is: "
        << numeric_limits<double>::denorm_min( ) << endl;
   cout << "The smallest nonzero denormalized value" << endl
        << "for long double objects is: "
        << numeric_limits<long double>::denorm_min( ) << endl;

   // A smaller value will round to zero
   cout << numeric_limits<float>::denorm_min( )/2 <<endl;
   cout << numeric_limits<double>::denorm_min( )/2 <<endl;
   cout << numeric_limits<long double>::denorm_min( )/2 <<endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << numeric_limits<float>::digits <<endl;
   cout << numeric_limits<double>::digits <<endl;
   cout << numeric_limits<long double>::digits <<endl;
   cout << numeric_limits<int>::digits <<endl;
   cout << numeric_limits<__int64>::digits <<endl;
}

24
53
53
31
63

digits10

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

static constexpr int digits10 = 0;

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

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

Пример

// numeric_limits_digits10.cpp
// compile with: /EHsc
#include <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << numeric_limits<float>::digits10 <<endl;
   cout << numeric_limits<double>::digits10 <<endl;
   cout << numeric_limits<long double>::digits10 <<endl;
   cout << numeric_limits<int>::digits10 <<endl;
   cout << numeric_limits<__int64>::digits10 <<endl;
   float f = (float)99999999;
   cout.precision ( 10 );
   cout << "The float is; " << f << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The difference between 1 and the smallest "
        << "value greater than 1" << endl
        << "for float objects is: "
        << numeric_limits<float>::epsilon( ) << endl;
   cout << "The difference between 1 and the smallest "
        << "value greater than 1" << endl
        << "for double objects is: "
        << numeric_limits<double>::epsilon( ) << endl;
   cout << "The difference between 1 and the smallest "
        << "value greater than 1" << endl
        << "for long double objects is: "
        << numeric_limits<long double>::epsilon( ) << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects allow denormalized values: "
        << numeric_limits<float>::has_denorm
        << endl;
   cout << "Whether double objects allow denormalized values: "
        << numeric_limits<double>::has_denorm
        << endl;
   cout << "Whether long int objects allow denormalized values: "
        << numeric_limits<long int>::has_denorm
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects can detect denormalized loss: "
        << numeric_limits<float>::has_denorm_loss
        << endl;
   cout << "Whether double objects can detect denormalized loss: "
        << numeric_limits<double>::has_denorm_loss
        << endl;
   cout << "Whether long int objects can detect denormalized loss: "
        << numeric_limits<long int>::has_denorm_loss
        << endl;
}

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_iec559true.

Пример

// numeric_limits_has_infinity.cpp
// compile with: /EHsc
#include <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have infinity: "
        << numeric_limits<float>::has_infinity
        << endl;
   cout << "Whether double objects have infinity: "
        << numeric_limits<double>::has_infinity
        << endl;
   cout << "Whether long int objects have infinity: "
        << numeric_limits<long int>::has_infinity
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have quiet_NaN: "
        << numeric_limits<float>::has_quiet_NaN
        << endl;
   cout << "Whether double objects have quiet_NaN: "
        << numeric_limits<double>::has_quiet_NaN
        << endl;
   cout << "Whether long int objects have quiet_NaN: "
        << numeric_limits<long int>::has_quiet_NaN
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have a signaling_NaN: "
        << numeric_limits<float>::has_signaling_NaN
        << endl;
   cout << "Whether double objects have a signaling_NaN: "
        << numeric_limits<double>::has_signaling_NaN
        << endl;
   cout << "Whether long int objects have a signaling_NaN: "
        << numeric_limits<long int>::has_signaling_NaN
        << endl;
}

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_infinitytrue.

Пример

// numeric_limits_infinity.cpp
// compile with: /EHsc
#include <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << numeric_limits<float>::has_infinity <<endl;
   cout << numeric_limits<double>::has_infinity<<endl;
   cout << numeric_limits<long double>::has_infinity <<endl;
   cout << numeric_limits<int>::has_infinity <<endl;
   cout << numeric_limits<__int64>::has_infinity <<endl;

   cout << "The representation of infinity for type float is: "
        << numeric_limits<float>::infinity( ) <<endl;
   cout << "The representation of infinity for type double is: "
        << numeric_limits<double>::infinity( ) <<endl;
   cout << "The representation of infinity for type long double is: "
        << numeric_limits<long double>::infinity( ) <<endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have bounded set "
        << "of representable values: "
        << numeric_limits<float>::is_bounded
        << endl;
   cout << "Whether double objects have bounded set "
        << "of representable values: "
        << numeric_limits<double>::is_bounded
        << endl;
   cout << "Whether long int objects have bounded set "
        << "of representable values: "
        << numeric_limits<long int>::is_bounded
        << endl;
   cout << "Whether unsigned char objects have bounded set "
        << "of representable values: "
        << numeric_limits<unsigned char>::is_bounded
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have calculations "
        << "free of rounding errors: "
        << numeric_limits<float>::is_exact
        << endl;
   cout << "Whether double objects have calculations "
        << "free of rounding errors: "
        << numeric_limits<double>::is_exact
        << endl;
   cout << "Whether long int objects have calculations "
        << "free of rounding errors: "
        << numeric_limits<long int>::is_exact
        << endl;
   cout << "Whether unsigned char objects have calculations "
        << "free of rounding errors: "
        << numeric_limits<unsigned char>::is_exact
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects conform to iec559 standards: "
        << numeric_limits<float>::is_iec559
        << endl;
   cout << "Whether double objects conform to iec559 standards: "
        << numeric_limits<double>::is_iec559
        << endl;
   cout << "Whether int objects conform to iec559 standards: "
        << numeric_limits<int>::is_iec559
        << endl;
   cout << "Whether unsigned char objects conform to iec559 standards: "
        << numeric_limits<unsigned char>::is_iec559
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have an integral representation: "
        << numeric_limits<float>::is_integer
        << endl;
   cout << "Whether double objects have an integral representation: "
        << numeric_limits<double>::is_integer
        << endl;
   cout << "Whether int objects have an integral representation: "
        << numeric_limits<int>::is_integer
        << endl;
   cout << "Whether unsigned char objects have an integral representation: "
        << numeric_limits<unsigned char>::is_integer
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have a modulo representation: "
        << numeric_limits<float>::is_modulo
        << endl;
   cout << "Whether double objects have a modulo representation: "
        << numeric_limits<double>::is_modulo
        << endl;
   cout << "Whether signed char objects have a modulo representation: "
        << numeric_limits<signed char>::is_modulo
        << endl;
   cout << "Whether unsigned char objects have a modulo representation: "
        << numeric_limits<unsigned char>::is_modulo
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have a signed representation: "
        << numeric_limits<float>::is_signed
        << endl;
   cout << "Whether double objects have a signed representation: "
        << numeric_limits<double>::is_signed
        << endl;
   cout << "Whether signed char objects have a signed representation: "
        << numeric_limits<signed char>::is_signed
        << endl;
   cout << "Whether unsigned char objects have a signed representation: "
        << numeric_limits<unsigned char>::is_signed
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float objects have an explicit "
        << "specialization in the class: "
        << numeric_limits<float>::is_specialized
        << endl;
   cout << "Whether float* objects have an explicit "
        << "specialization in the class: "
        << numeric_limits<float*>::is_specialized
        << endl;
   cout << "Whether int objects have an explicit "
        << "specialization in the class: "
        << numeric_limits<int>::is_specialized
        << endl;
   cout << "Whether int* objects have an explicit "
        << "specialization in the class: "
        << numeric_limits<int*>::is_specialized
        << endl;
}

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 для типа intfloat. Возвращаемое значение имеет смысл, если is_boundedtrue.

Пример

// numeric_limits_max.cpp
// compile with: /EHsc
#include <iostream>
#include <limits>

using namespace std;

int main() {
   cout << "The maximum value for type float is:  "
        << numeric_limits<float>::max( )
        << endl;
   cout << "The maximum value for type double is:  "
        << numeric_limits<double>::max( )
        << endl;
   cout << "The maximum value for type int is:  "
        << numeric_limits<int>::max( )
        << endl;
   cout << "The maximum value for type short int is:  "
        << numeric_limits<short int>::max( )
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The maximum radix-based exponent for type float is:  "
        << numeric_limits<float>::max_exponent
        << endl;
   cout << "The maximum radix-based exponent for type double is:  "
        << numeric_limits<double>::max_exponent
        << endl;
   cout << "The maximum radix-based exponent for type long double is:  "
        << numeric_limits<long double>::max_exponent
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The maximum base 10 exponent for type float is:  "
           << numeric_limits<float>::max_exponent10
           << endl;
   cout << "The maximum base 10 exponent for type double is:  "
           << numeric_limits<double>::max_exponent10
           << endl;
   cout << "The maximum base 10 exponent for type long double is:  "
           << numeric_limits<long double>::max_exponent10
           << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The minimum value for type float is:  "
        << numeric_limits<float>::min( )
        << endl;
   cout << "The minimum value for type double is:  "
        << numeric_limits<double>::min( )
        << endl;
   cout << "The minimum value for type int is:  "
        << numeric_limits<int>::min( )
        << endl;
   cout << "The minimum value for type short int is:  "
        << numeric_limits<short int>::min( )
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The minimum radix-based exponent for type float is:  "
        << numeric_limits<float>::min_exponent
        << endl;
   cout << "The minimum radix-based exponent for type double is:  "
        << numeric_limits<double>::min_exponent
        << endl;
   cout << "The minimum radix-based exponent for type long double is:  "
         << numeric_limits<long double>::min_exponent
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The minimum base 10 exponent for type float is:  "
        << numeric_limits<float>::min_exponent10
        << endl;
   cout << "The minimum base 10 exponent for type double is:  "
        << numeric_limits<double>::min_exponent10
        << endl;
   cout << "The minimum base 10 exponent for type long double is:  "
        << numeric_limits<long double>::min_exponent10
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The quiet NaN for type float is:  "
        << numeric_limits<float>::quiet_NaN( )
        << endl;
   cout << "The quiet NaN for type int is:  "
        << numeric_limits<int>::quiet_NaN( )
        << endl;
   cout << "The quiet NaN for type long double is:  "
        << numeric_limits<long double>::quiet_NaN( )
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The base for type float is:  "
        << numeric_limits<float>::radix
        << endl;
   cout << "The base for type int is:  "
        << numeric_limits<int>::radix
        << endl;
   cout << "The base for type long double is:  "
        << numeric_limits<long double>::radix
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The maximum rounding error for type float is:  "
        << numeric_limits<float>::round_error( )
        << endl;
   cout << "The maximum rounding error for type int is:  "
        << numeric_limits<int>::round_error( )
        << endl;
   cout << "The maximum rounding error for type long double is:  "
        << numeric_limits<long double>::round_error( )
        << endl;
}

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 <iostream>
#include <float.h>
#include <limits>

using namespace std;

int main( )
{
   cout << "The rounding style for a double type is: "
        << numeric_limits<double>::round_style << endl;
   _controlfp_s(NULL,_RC_DOWN,_MCW_RC );
   cout << "The rounding style for a double type is now: "
        << numeric_limits<double>::round_style << endl;
   cout << "The rounding style for an int type is: "
        << numeric_limits<int>::round_style << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "The signaling NaN for type float is:  "
        << numeric_limits<float>::signaling_NaN( )
        << endl;
   cout << "The signaling NaN for type int is:  "
        << numeric_limits<int>::signaling_NaN( )
        << endl;
   cout << "The signaling NaN for type long double is:  "
        << numeric_limits<long double>::signaling_NaN( )
        << endl;
}

tinyness_before

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

static constexpr bool tinyness_before = false;

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

true, если тип перед округлением может определить, что значение слишком мало; в противном случае false.

Замечания

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

Пример

// numeric_limits_tinyness_before.cpp
// compile with: /EHsc
#include <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float types can detect tinyness before rounding: "
        << numeric_limits<float>::tinyness_before
        << endl;
   cout << "Whether double types can detect tinyness before rounding: "
        << numeric_limits<double>::tinyness_before
        << endl;
   cout << "Whether long int types can detect tinyness before rounding: "
        << numeric_limits<long int>::tinyness_before
        << endl;
   cout << "Whether unsigned char types can detect tinyness before rounding: "
        << numeric_limits<unsigned char>::tinyness_before
        << endl;
}

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 <iostream>
#include <limits>

using namespace std;

int main( )
{
   cout << "Whether float types have implemented trapping: "
        << numeric_limits<float>::traps
        << endl;
   cout << "Whether double types have implemented trapping: "
        << numeric_limits<double>::traps
        << endl;
   cout << "Whether long int types have implemented trapping: "
        << numeric_limits<long int>::traps
        << endl;
   cout << "Whether unsigned char types have implemented trapping: "
        << numeric_limits<unsigned char>::traps
        << endl;
}

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