numeric_limits — Klasa

Artykuł
06/16/2023

Szablon klasy opisuje właściwości arytmetyczne wbudowanych typów liczbowych.

Składnia

template <class Type>
    class numeric_limits

Parametry

Type
Podstawowy typ danych elementu, którego właściwości są testowane lub wykonywane zapytania lub ustawiane. Można również zadeklarować consttyp , volatilelub const volatile.

Uwagi

Nagłówek definiuje jawne specjalizacje typów wchar_t, , boolunsigned long longintunsigned shortunsigned intshortlongunsigned charunsigned longfloatsigned charcharlong doublelong longdoublechar16_ti .char32_t W przypadku tych jawnych specjalizacji element członkowski numeric_limits::is_specialized to true, a wszystkie odpowiednie elementy członkowskie mają znaczące wartości. Program może dostarczać dodatkowe jawne specjalizacje. Większość funkcji składowych klasy opisuje lub testuje możliwe implementacje klasy float.

W przypadku dowolnej specjalizacji żadne elementy członkowskie nie mają znaczących wartości. Obiekt członkowski, który nie ma znaczącej wartości, przechowuje zero (lub false) i funkcję składową, która nie zwraca znaczącej wartości zwraca wartość Type(0).

Funkcje statyczne i stałe

Nazwa/nazwisko	opis
denorm_min	Zwraca najmniejszą niezerowo zdenormalizowaną wartość.
Cyfr	Zwraca liczbę cyfr promieniowych, które typ może reprezentować bez utraty dokładności.
digits10	Zwraca liczbę cyfr dziesiętnych, które typ może reprezentować bez utraty dokładności.
Epsilon	Zwraca różnicę między 1 a najmniejszą wartością większą niż 1, którą może reprezentować typ danych.
has_denorm	Sprawdza, czy typ zezwala na zdenormalizowane wartości.
has_denorm_loss	Sprawdza, czy utrata dokładności jest wykrywana jako utrata denormalizacji, a nie jako wynik niewykonany.
has_infinity	Sprawdza, czy typ ma reprezentację dodatniej nieskończoności.
has_quiet_NaN	Sprawdza, czy typ ma reprezentację dla cichej, a nie liczby (NAN), która nie jest sygnałem.
has_signaling_NaN	Sprawdza, czy typ ma reprezentację sygnału nie liczby (NAN).
nieskończoność	Reprezentacja dodatniej nieskończoności dla typu, jeśli jest dostępna.
is_bounded	Sprawdza, czy zestaw wartości, które może reprezentować typ, jest skończony.
is_exact	Sprawdza, czy obliczenia wykonywane na typie są wolne od błędów zaokrąglania.
is_iec559	Sprawdza, czy typ jest zgodny ze standardami IEC 559.
is_integer	Sprawdza, czy typ ma reprezentację całkowitą.
is_modulo	Sprawdza, czy typ ma reprezentację modulo.
is_signed	Sprawdza, czy typ ma podpisaną reprezentację.
is_specialized	Sprawdza, czy typ ma jawną specjalizację zdefiniowaną w szablonie `numeric_limits`klasy .
Najniższej	Zwraca najbardziej ujemną wartość skończoną.
Max	Zwraca maksymalną wartość skończona dla typu.
max_digits10	Zwraca liczbę cyfr dziesiętnych wymaganych do zapewnienia, że dwie odrębne wartości typu mają odrębne reprezentacje dziesiętne.
max_exponent	Zwraca maksymalny wykładnik całkowity dodatni, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa promienia jest podniesiona do tej mocy.
max_exponent10	Zwraca maksymalny dodatni wykładnik całkowity, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa dziesięciu zostanie podniesiona do tej mocy.
Min	Zwraca minimalną znormalizowaną wartość dla typu.
min_exponent	Zwraca maksymalny wykładnik całkowity ujemny, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa promienia jest podniesiona do tej mocy.
min_exponent10	Zwraca maksymalny wykładnik całkowity ujemny, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa dziesięciu zostanie podniesiona do tej mocy.
quiet_NaN	Zwraca reprezentację cichej, a nie liczby (NAN) dla typu.
podstawa	Zwraca podstawę całkowitą, określaną jako radix, używaną do reprezentacji typu.
round_error	Zwraca maksymalny błąd zaokrąglania dla typu.
round_style	Zwraca wartość opisującą różne metody, które implementacja może wybrać do zaokrąglania wartości zmiennoprzecinkowej do wartości całkowitej.
signaling_NaN	Zwraca reprezentację sygnału, który nie jest liczbą (NAN) dla typu.
tinyness_before	Sprawdza, czy typ może określić, czy wartość jest zbyt mała, aby reprezentować ją jako znormalizowaną wartość przed zaokrągleniem.
Pułapki	Sprawdza, czy podlewanie raportów dotyczących wyjątków arytmetycznych jest implementowane dla typu.

denorm_min

Zwraca najmniejszą niezerowo zdenormalizowaną wartość.

static constexpr Type denorm_min() throw();

Wartość zwracana

Najmniejsza niezerowa wartość zdenormalizowana.

Uwagi

long double jest taka sama jak double w przypadku kompilatora języka C++.

Funkcja zwraca minimalną wartość dla typu, która jest taka sama jak minimalna , jeśli has_denorm nie jest równa denorm_present.

Przykład

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

cyfry

Zwraca liczbę cyfr promieniowych, które typ może reprezentować bez utraty dokładności.

static constexpr int digits = 0;

Wartość zwracana

Liczba cyfr promieniowych, które typ może reprezentować bez utraty precyzji.

Uwagi

Element członkowski przechowuje liczbę cyfr promieniowych, które typ może reprezentować bez zmiany, czyli liczbę bitów innych niż jakikolwiek bit znaku dla wstępnie zdefiniowanego typu całkowitego lub liczbę cyfr mantissa dla wstępnie zdefiniowanego typu zmiennoprzecinkowego.

Przykład

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

digits10

Zwraca liczbę cyfr dziesiętnych, które typ może reprezentować bez utraty dokładności.

static constexpr int digits10 = 0;

Wartość zwracana

Liczba cyfr dziesiętnych, które typ może reprezentować bez utraty dokładności.

Przykład

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

Funkcja zwraca różnicę między 1 a najmniejszą wartością większą niż 1, która jest reprezentowana dla typu danych.

static constexpr Type epsilon() throw();

Wartość zwracana

Różnica między 1 i najmniejszą wartością większą niż 1, która jest reprezentowana dla typu danych.

Uwagi

Wartość jest FLT_EPSILON dla typu float. epsilondla typu jest najmniejsza dodatnia liczba zmiennoprzecinkowa N, taka że Nepsilon + + N jest reprezentowana.

Przykład

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

Sprawdza, czy typ zezwala na zdenormalizowane wartości.

static constexpr float_denorm_style has_denorm = denorm_absent;

Wartość zwracana

Wartość wyliczenia typu const float_denorm_style, wskazująca, czy typ zezwala na zdenormalizowane wartości.

Uwagi

Składowe przechowuje denorm_present dla typu zmiennoprzecinkowego, który ma zdenormalizowane wartości, skutecznie zmienną liczbę bitów wykładniczych.

Przykład

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

Sprawdza, czy utrata dokładności jest wykrywana jako utrata denormalizacji, a nie jako wynik niewykonany.

static constexpr bool has_denorm_loss = false;

Wartość zwracana

true w przypadku wykrycia utraty dokładności jako utraty denormalizacji; false jeśli nie.

Uwagi

Składowa przechowuje wartość true dla typu, który określa, czy wartość straciła dokładność, ponieważ jest dostarczana jako nienormalizowany wynik (zbyt mały, aby reprezentować jako znormalizowaną wartość) lub dlatego, że jest nieistniejąca (nie taka sama jak wynik nie podlega ograniczeniom zakresu wykładniczego i precyzji), opcja z reprezentacjami zmiennoprzecinkowych IEC 559, które mogą mieć wpływ na niektóre wyniki.

Przykład

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

Sprawdza, czy typ ma reprezentację dodatniej nieskończoności.

static constexpr bool has_infinity = false;

Wartość zwracana

true jeśli typ ma reprezentację dodatniej nieskończoności; false jeśli nie.

Uwagi

Element członkowski zwraca true wartość , jeśli is_iec559 to true.

Przykład

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

Sprawdza, czy typ ma reprezentację dla cichej, a nie liczby (NAN), która nie jest podpisem.

static constexpr bool has_quiet_NaN = false;

Wartość zwracana

truejeśli typ ma reprezentację cichej nazwy NAN; false jeśli nie.

Uwagi

Cicha funkcja NAN jest kodowaniem nie liczby, która nie sygnalizuje jego obecności w wyrażeniu. Wartość zwracana jest true , jeśli is_iec559 ma wartość true.

Przykład

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

Sprawdza, czy typ ma reprezentację sygnału nie liczby (NAN).

static constexpr bool has_signaling_NaN = false;

Wartość zwracana

true jeśli typ ma reprezentację sygnału NAN; false jeśli nie.

Uwagi

Sygnalizowanie NAN to kodowanie nie liczby, która sygnalizuje jego obecność w wyrażeniu. Wartość zwracana jest true , jeśli is_iec559 ma wartość true.

Przykład

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

nieskończoność

Reprezentacja nieskończoności dodatniej dla typu, jeśli jest dostępna.

static constexpr Type infinity() throw();

Wartość zwracana

Reprezentacja nieskończoności dodatniej dla typu, jeśli jest dostępna.

Uwagi

Wartość zwracana jest zrozumiała tylko wtedy, gdy has_infinity to true.

Przykład

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

Sprawdza, czy zestaw wartości, które może reprezentować typ, jest skończony.

static constexpr bool is_bounded = false;

Wartość zwracana

true jeśli typ ma powiązany zestaw godnych reprezentowania wartości; false jeśli nie.

Uwagi

Wszystkie wstępnie zdefiniowane typy mają ograniczony zestaw godnych reprezentowania wartości i zwracają wartość true.

Przykład

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

Sprawdza, czy obliczenia wykonywane na typie są wolne od błędów zaokrąglania.

static constexpr bool is_exact = false;

Wartość zwracana

true jeśli obliczenia są wolne od błędów zaokrąglania; false jeśli nie.

Uwagi

Wszystkie wstępnie zdefiniowane typy liczb całkowitych mają dokładne reprezentacje ich wartości i zwracają wartość false. Reprezentacja stałoprzecinkowa lub racjonalna jest również uważana za dokładną, ale reprezentacja zmiennoprzecinkowa nie jest.

Przykład

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

Sprawdza, czy typ jest zgodny ze standardami IEC 559.

static constexpr bool is_iec559 = false;

Wartość zwracana

true jeżeli typ jest zgodny z normami IEC 559; false jeśli nie.

Uwagi

IEC 559 jest międzynarodowym standardem reprezentującym wartości zmiennoprzecinkowe i jest również znany jako IEEE 754 w USA.

Przykład

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

Sprawdza, czy typ ma reprezentację całkowitą.

static constexpr bool is_integer = false;

Wartość zwracana

true jeśli typ ma reprezentację całkowitą; false jeśli nie.

Uwagi

Wszystkie wstępnie zdefiniowane typy liczb całkowitych mają reprezentację całkowitą.

Przykład

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

Sprawdza, czy typ ma reprezentację modulo.

static constexpr bool is_modulo = false;

Wartość zwracana

true jeśli typ ma reprezentację modulo; false jeśli nie.

Uwagi

Reprezentacja modulo jest reprezentacją, w której wszystkie wyniki są zmniejszone modulo pewnej wartości. Wszystkie wstępnie zdefiniowane niepodpisane typy liczb całkowitych mają reprezentację modulo.

Przykład

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

Sprawdza, czy typ ma podpisaną reprezentację.

static constexpr bool is_signed = false;

Wartość zwracana

true jeśli typ ma podpisaną reprezentację; false jeśli nie.

Uwagi

Element członkowski przechowuje wartość true dla typu, który ma podpisaną reprezentację, co jest w przypadku wszystkich wstępnie zdefiniowanych typów zmiennoprzecinkowych i podpisanych liczb całkowitych.

Przykład

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

Sprawdza, czy typ ma jawną specjalizację zdefiniowaną w szablonie numeric_limitsklasy .

static constexpr bool is_specialized = false;

Wartość zwracana

true jeśli typ ma jawną specjalizację zdefiniowaną w szablonie klasy; false jeśli nie.

Uwagi

Wszystkie typy skalarne inne niż wskaźniki mają jawną specjalizację zdefiniowaną dla szablonu numeric_limitsklasy .

Przykład

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

najniższy

Zwraca najbardziej ujemną wartość skończoną.

static constexpr Type lowest() throw();

Wartość zwracana

Zwraca najbardziej ujemną wartość skończoną.

Uwagi

Zwraca najbardziej ujemną wartość skończona dla typu (zazwyczaj dla min() typów całkowitych i -max() dla typów zmiennoprzecinkowych). Wartość zwracana jest znacząca, jeśli is_bounded jest to true.

max

Zwraca maksymalną wartość skończona dla typu.

static constexpr Type max() throw();

Wartość zwracana

Maksymalna wartość skończona dla typu.

Uwagi

Maksymalna wartość skończona jest INT_MAX dla typu int i FLT_MAX dla typu float. Wartość zwracana jest znacząca, jeśli is_bounded to true.

Przykład

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

Zwraca liczbę cyfr dziesiętnych wymaganych do upewnienia się, że dwie odrębne wartości typu mają unikatowe reprezentacje dziesiętne.

static constexpr int max_digits10 = 0;

Wartość zwracana

Zwraca liczbę cyfr dziesiętnych, które są wymagane, aby upewnić się, że dwie odrębne wartości typu mają różne reprezentacje dziesiętne.

Uwagi

Element członkowski przechowuje liczbę cyfr dziesiętnych wymaganych do upewnienia się, że dwie odrębne wartości typu mają różne reprezentacje dziesiętne.

max_exponent

Zwraca maksymalny wykładnik całkowity dodatni, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa promienia jest podniesiona do tej mocy.

static constexpr int max_exponent = 0;

Wartość zwracana

Maksymalny wykładnik oparty na promieniach całkowitych reprezentowany przez typ.

Uwagi

Zwracana funkcja składowa ma znaczenie tylko dla typów zmiennoprzecinkowych. Jest max_exponent to wartość FLT_MAX_EXP dla typu float.

Przykład

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

Zwraca maksymalny dodatni wykładnik całkowity, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa dziesięciu zostanie podniesiona do tej mocy.

static constexpr int max_exponent10 = 0;

Wartość zwracana

Maksymalna całkowita podstawa 10 wykładnika reprezentowana przez typ.

Uwagi

Zwracana funkcja składowa ma znaczenie tylko dla typów zmiennoprzecinkowych. Jest max_exponent to wartość FLT_MAX_10 dla typu float.

Przykład

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

min

Zwraca minimalną znormalizowaną wartość dla typu.

static constexpr Type min() throw();

Wartość zwracana

Minimalna znormalizowana wartość typu.

Uwagi

Minimalna znormalizowana wartość jest INT_MIN dla typu int i FLT_MIN dla typu float. Wartość zwracana jest zrozumiała, jeśli is_bounded to true lub jeśli is_signed to false.

Przykład

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

Zwraca maksymalny wykładnik całkowity ujemny, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa promienia jest podniesiona do tej mocy.

static constexpr int min_exponent = 0;

Wartość zwracana

Minimalny wykładnik oparty na promieniach całkowitych reprezentowany przez typ.

Uwagi

Funkcja składowa jest zrozumiała tylko dla typów zmiennoprzecinkowych. Jest min_exponent to wartość FLT_MIN_EXP dla typu float.

Przykład

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

Zwraca maksymalny wykładnik całkowity ujemny, który typ zmiennoprzecinkowy może reprezentować jako wartość skończona, gdy podstawa dziesięciu zostanie podniesiona do tej mocy.

static constexpr int min_exponent10 = 0;

Wartość zwracana

Minimalna całkowita podstawa 10 wykładnika reprezentowana przez typ.

Uwagi

Funkcja składowa jest zrozumiała tylko dla typów zmiennoprzecinkowych. Jest min_exponent10 to wartość FLT_MIN_10_EXP dla typu float.

Przykład

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

Zwraca reprezentację cichej, a nie liczby (NAN) dla typu.

static constexpr Type quiet_NaN() throw();

Wartość zwracana

Reprezentacja cichej nazwy NAN dla typu.

Uwagi

Wartość zwracana jest zrozumiała tylko wtedy, gdy has_quiet_NaN to true.

Przykład

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

podstawa

Zwraca podstawę całkowitą, określaną jako radix, używaną do reprezentacji typu.

static constexpr int radix = 0;

Wartość zwracana

Całkowita podstawa dla reprezentacji typu.

Uwagi

Podstawa to 2 dla wstępnie zdefiniowanych typów liczb całkowitych, a podstawa, do której jest wywoływany wykładnik lub FLT_RADIX dla wstępnie zdefiniowanych typów zmiennoprzecinkowych.

Przykład

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

Zwraca maksymalny błąd zaokrąglania dla typu.

static constexpr Type round_error() throw();

Wartość zwracana

Maksymalny błąd zaokrąglania dla typu.

Przykład

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

Zwraca wartość opisującą różne metody, które implementacja może wybrać do zaokrąglania wartości zmiennoprzecinkowej do wartości całkowitej.

static constexpr float_round_style round_style = round_toward_zero;

Wartość zwracana

Wartość z float_round_style wyliczenia, która opisuje styl zaokrąglania.

Uwagi

Element członkowski przechowuje wartość opisującą różne metody, które implementacja może wybrać do zaokrąglania wartości zmiennoprzecinkowej do wartości całkowitej.

Styl okrągły jest zakodowany w tej implementacji, więc nawet jeśli program uruchamia się w innym trybie zaokrąglania, ta wartość nie ulegnie zmianie.

Przykład

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

Zwraca reprezentację sygnału, który nie jest liczbą (NAN) dla typu.

static constexpr Type signaling_NaN() throw();

Wartość zwracana

Reprezentacja sygnału NAN dla typu.

Uwagi

Wartość zwracana jest zrozumiała tylko wtedy, gdy has_signaling_NaN to true.

Przykład

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

Sprawdza, czy typ może określić, czy wartość jest zbyt mała, aby reprezentować ją jako znormalizowaną wartość przed zaokrągleniem.

static constexpr bool tinyness_before = false;

Wartość zwracana

true jeśli typ może wykryć małe wartości przed zaokrągleniem; false jeśli nie może.

Uwagi

Typy, które mogą wykryć małość, zostały uwzględnione jako opcja z reprezentacjami zmiennoprzecinkowych IEC 559, a jej implementacja może mieć wpływ na niektóre wyniki.

Przykład

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

błędów

Sprawdza, czy podlewanie raportów dotyczących wyjątków arytmetycznych jest implementowane dla typu.

static constexpr bool traps = false;

Wartość zwracana

true w przypadku implementacji podlewek dla typu; false jeśli tak nie jest.

Przykład

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

Udostępnij za pośrednictwem

numeric_limits — Klasa

Składnia

Parametry

Uwagi

Funkcje statyczne i stałe

denorm_min

Wartość zwracana

Uwagi

Przykład

cyfry

Wartość zwracana

Uwagi

Przykład

digits10

Wartość zwracana

Przykład

Epsilon

Wartość zwracana

Uwagi

Przykład

has_denorm

Wartość zwracana

Uwagi

Przykład

has_denorm_loss

Wartość zwracana

Uwagi

Przykład

has_infinity

Wartość zwracana

Uwagi

Przykład

has_quiet_NaN

Wartość zwracana

Uwagi

Przykład

has_signaling_NaN

Wartość zwracana

Uwagi

Przykład

nieskończoność

Wartość zwracana

Uwagi

Przykład

is_bounded

Wartość zwracana

Uwagi

Przykład

is_exact

Wartość zwracana

Uwagi

Przykład

is_iec559

Wartość zwracana

Uwagi

Przykład

is_integer

Wartość zwracana

Uwagi

Przykład

is_modulo

Wartość zwracana

Uwagi

Przykład

is_signed

Wartość zwracana

Uwagi

Przykład

is_specialized

Wartość zwracana

Uwagi

Przykład

najniższy

Wartość zwracana

Uwagi

max

Wartość zwracana

Uwagi

Przykład