numeric_limits – třída

Článek
08/04/2024

Šablona třídy popisuje aritmetické vlastnosti předdefinovaných číselných typů.

Syntaxe

template <class Type>
    class numeric_limits

Parametry

Typ
Základní datový typ elementu, jehož vlastnosti jsou testovány nebo dotazovány nebo nastaveny. Typ lze také deklarovat const, volatilenebo const volatile.

Poznámky

Hlavička definuje explicitní specializace pro typy wchar_t, , bool, char, signed char, shortunsigned char, unsigned short, doubleunsigned intlonglong longlong doublefloatintunsigned long, , , unsigned long longa . char16_tchar32_t Pro tyto explicitní specializace člen numeric_limits::is_specialized je truea všichni relevantní členové mají smysluplné hodnoty. Program může poskytovat další explicitní specializace. Většina členských funkcí třídy popisuje nebo testuje možné implementace float.

Pro libovolnou specializaci nemají žádní členové smysluplné hodnoty. Objekt člena, který nemá smysluplnou hodnotu, ukládá nula (nebo false) a členské funkce, která nevrací smysluplnou hodnotu vrátí Type(0).

Statické funkce a konstanty

Název	Popis
denorm_min	Vrátí nejmenší nenulovou denormalizovanou hodnotu.
číslice	Vrátí počet číslic radix, které může typ představovat bez ztráty přesnosti.
číslice10	Vrátí počet desetinných číslic, které může typ představovat bez ztráty přesnosti.
epsilon	Vrátí rozdíl mezi 1 a nejmenší hodnotou větší než 1, kterou může datový typ představovat.
has_denorm	Testuje, zda typ umožňuje denormalizované hodnoty.
has_denorm_loss	Testuje, zda je ztráta přesnosti zjištěna jako denormalizační ztráta, nikoli jako neaktuální výsledek.
has_infinity	Testuje, zda typ má reprezentaci pro kladné nekonečno.
has_quiet_NaN	Testuje, zda typ má reprezentaci pro tiché ne číslo (NAN), což není signalizovat.
has_signaling_NaN	Testuje, zda typ má reprezentaci pro signalizaci, ne číslo (NAN).
nekonečno	Reprezentace kladného nekonečna pro typ, pokud je k dispozici.
is_bounded	Testuje, zda je sada hodnot, které může typ představovat, konečný.
is_exact	Testuje, jestli výpočty provedené u typu nejsou zaokrouhlené.
is_iec559	Testuje, zda typ vyhovuje standardům IEC 559.
is_integer	Testuje, jestli má typ celočíselnou reprezentaci.
is_modulo	Testuje, zda má typ reprezentaci modulo.
is_signed	Testuje, jestli typ obsahuje podepsanou reprezentaci.
is_specialized	Testuje, zda typ má explicitní specializaci definovanou v šabloně `numeric_limits`třídy .
nejnižší	Vrátí největší omezenou zápornou hodnotu.
Max	Vrátí maximální konečnou hodnotu pro typ.
max_digits10	Vrátí počet desetinných číslic potřebných k zajištění toho, aby dvě jedinečné hodnoty typu měly odlišné desetinné číslo.
max_exponent	Vrátí maximální kladnou celočíselnou exponent, kterou typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna radixu.
max_exponent10	Vrátí maximální kladnou celočíselnou exponent, kterou typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna deseti.
Min	Vrátí minimální normalizovanou hodnotu pro typ.
min_exponent	Vrátí maximální záporný celočíselný exponent, který typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna radixu.
min_exponent10	Vrátí maximální záporný celočíselný exponent, který typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna deseti.
quiet_NaN	Vrátí reprezentaci ticha, nikoli čísla (NAN) pro typ.
základ	Vrátí celočíselnou základnu, která se označuje jako radix, použitá pro reprezentaci typu.
round_error	Vrátí maximální chybu zaokrouhlení typu.
round_style	Vrátí hodnotu, která popisuje různé metody, které implementace může zvolit pro zaokrouhlení hodnoty s plovoucí desetinou čárkou na celočíselnou hodnotu.
signaling_NaN	Vrátí reprezentaci signálu, nikoli čísla (NAN) pro typ.
tinyness_before	Testuje, zda typ může určit, že hodnota je příliš malá, aby byla reprezentována jako normalizovaná hodnota před zaokrouhlení.
pasti	Testuje, zda je u typu implementováno zachytnutí, které hlásí aritmetické výjimky.

denorm_min

Vrátí nejmenší nenulovou denormalizovanou hodnotu.

static constexpr Type denorm_min() throw();

Návratová hodnota

Nejmenší nenulová denormalizovaná hodnota.

Poznámky

long double je stejný jako double pro kompilátor jazyka C++.

Funkce vrátí minimální hodnotu pro typ, která je stejná jako min , pokud has_denorm není rovna denorm_present.

Příklad

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

číslice

Vrátí počet číslic radix, které může typ představovat bez ztráty přesnosti.

static constexpr int digits = 0;

Návratová hodnota

Počet číslic radix, které může typ představovat bez ztráty přesnosti.

Poznámky

Člen uloží počet číslic radix, které typ může představovat beze změny, což je počet bitů kromě libovolného znaménka pro předdefinovaný celočíselný typ nebo počet číslic mantissa pro předdefinovaný typ s plovoucí desetinou čárkou.

Příklad

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

číslice10

Vrátí počet desetinných číslic, které může typ představovat bez ztráty přesnosti.

static constexpr int digits10 = 0;

Návratová hodnota

Počet desetinných číslic, které může typ představovat bez ztráty přesnosti.

Příklad

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

Funkce vrátí rozdíl mezi 1 a nejmenší hodnotou větší než 1, která je reprezentovatelná pro datový typ.

static constexpr Type epsilon() throw();

Návratová hodnota

Rozdíl mezi 1 a nejmenší hodnotou větší než 1, která je reprezentovatelná pro datový typ.

Poznámky

Hodnota je FLT_EPSILON pro typ float. epsilonpro typ je nejmenší kladné číslo s plovoucí desetinnou čárkou N tak, že Nepsilon + + N je reprezentovatelné.

Příklad

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

Testuje, zda typ umožňuje denormalizované hodnoty.

static constexpr float_denorm_style has_denorm = denorm_absent;

Návratová hodnota

Hodnota výčtu typu const float_denorm_styleoznačující, zda typ umožňuje denormalizované hodnoty.

Poznámky

Člen ukládá denorm_present pro typ s plovoucí desetinnou čárkou, který má denormalizované hodnoty, a v podstatě proměnný počet exponentů bitů.

Příklad

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

Testuje, zda je ztráta přesnosti zjištěna jako denormalizační ztráta, nikoli jako neaktuální výsledek.

static constexpr bool has_denorm_loss = false;

Návratová hodnota

true je-li ztráta přesnosti zjištěna jako denormalizace ztráta; false jestliže ne.

Poznámky

Člen ukládá hodnotu true pro typ, který určuje, zda hodnota ztratila přesnost, protože je doručena jako denormalizovaný výsledek (příliš malý na reprezentaci jako normalizovaná hodnota), nebo protože je neaktuální (nikoli stejný jako výsledek, který není předmětem omezení exponent rozsahu a přesnosti), možnost s reprezentací s plovoucí desetinnou čárkou IEC 559, která může ovlivnit některé výsledky.

Příklad

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

Testuje, zda typ má reprezentaci pro kladné nekonečno.

static constexpr bool has_infinity = false;

Návratová hodnota

true pokud typ má reprezentaci pro kladné nekonečno; false jestliže ne.

Poznámky

Člen vrátítrue, pokud je trueis_iec559 .

Příklad

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

Testuje, zda typ má reprezentaci pro tiché ne číslo (NAN), což není znaménka.

static constexpr bool has_quiet_NaN = false;

Návratová hodnota

true pokud má typ reprezentaci tichého názvu NAN, false pokud ne.

Poznámky

Tichý NAN je kódování pro ne číslo, které neoznamuje jeho přítomnost ve výrazu. Vrácená hodnota je true , pokud je is_iec559 pravdivá.

Příklad

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

Testuje, zda typ má reprezentaci pro signalizaci, ne číslo (NAN).

static constexpr bool has_signaling_NaN = false;

Návratová hodnota

true má-li typ reprezentaci signálu NAN; false jestliže ne.

Poznámky

Signalizační NAN je kódování pro ne číslo, které signalizuje jeho přítomnost ve výrazu. Vrácená hodnota je true , pokud je is_iec559 pravdivá.

Příklad

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

nekonečno

Reprezentace kladného nekonečna pro typ, pokud je k dispozici.

static constexpr Type infinity() throw();

Návratová hodnota

Reprezentace kladného nekonečna pro typ, pokud je k dispozici.

Poznámky

Návratová hodnota je smysluplná pouze v případě, že has_infinity je true.

Příklad

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

Testuje, zda je sada hodnot, které může typ představovat, konečný.

static constexpr bool is_bounded = false;

Návratová hodnota

true má-li typ ohraničenou sadu reprezentovatelných hodnot; false jestliže ne.

Poznámky

Všechny předdefinované typy mají ohraničenou sadu reprezentovatelných hodnot a vrací true.

Příklad

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

Testuje, jestli výpočty provedené u typu nejsou zaokrouhlené.

static constexpr bool is_exact = false;

Návratová hodnota

true jsou-li výpočty bez zaokrouhlení chyb; false jestliže ne.

Poznámky

Všechny předdefinované celočíselné typy mají přesné vyjádření jejich hodnot a návratu false. Pevná nebo racionalizační reprezentace se také považuje za přesnou, ale reprezentace s plovoucí desetinou čárkou není.

Příklad

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

Testuje, zda typ vyhovuje standardům IEC 559.

static constexpr bool is_iec559 = false;

Návratová hodnota

true pokud typ odpovídá normám IEC 559; false jestliže ne.

Poznámky

IEC 559 je mezinárodní standard pro reprezentaci hodnot s plovoucí desetinou čárkou a v USA se také označuje jako IEEE 754.

Příklad

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

Testuje, jestli má typ celočíselnou reprezentaci.

static constexpr bool is_integer = false;

Návratová hodnota

true má-li typ celočíselnou reprezentaci; false jestliže ne.

Poznámky

Všechny předdefinované celočíselné typy mají celočíselnou reprezentaci.

Příklad

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

Testuje, zda má typ reprezentaci modulo.

static constexpr bool is_modulo = false;

Návratová hodnota

true má-li typ reprezentaci modulo; false jestliže ne.

Poznámky

Reprezentace modulu je reprezentace, ve které jsou všechny výsledky sníženy o určitou hodnotu. Všechny předdefinované celočíselné typy bez znaménka mají reprezentaci moduluo.

Příklad

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

Testuje, jestli typ obsahuje podepsanou reprezentaci.

static constexpr bool is_signed = false;

Návratová hodnota

true má-li typ podepsanou reprezentaci; false jestliže ne.

Poznámky

Člen uloží hodnotu true pro typ, který má podepsanou reprezentaci, což je případ pro všechny předdefinované typy s plovoucí desetinou čárkou a podepsanými celými čísly.

Příklad

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

Testuje, zda typ má explicitní specializaci definovanou v šabloně numeric_limitstřídy .

static constexpr bool is_specialized = false;

Návratová hodnota

true pokud typ má explicitní specializaci definovanou v šabloně třídy; false jestliže ne.

Poznámky

Všechny skalární typy kromě ukazatelů mají explicitní specializaci definovanou pro šablonu numeric_limitstřídy .

Příklad

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

nejnižší

Vrátí největší omezenou zápornou hodnotu.

static constexpr Type lowest() throw();

Návratová hodnota

Vrátí největší omezenou zápornou hodnotu.

Poznámky

Vrátí nejvíce zápornou konečnou hodnotu pro typ (což je obvykle min() pro celočíselné typy a -max() pro typy s plovoucí desetinou čárkou). Návratová hodnota je smysluplná, pokud is_bounded je true.

max

Vrátí maximální konečnou hodnotu pro typ.

static constexpr Type max() throw();

Návratová hodnota

Maximální konečná hodnota pro typ.

Poznámky

Maximální konečná hodnota je INT_MAX pro typ int a FLT_MAX pro typ float. Návratová hodnota je smysluplná, pokud je trueis_bounded .

Příklad

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

Vrátí počet desetinných číslic požadovaných k zajištění, že dvě odlišné hodnoty typu mají odlišné desítkové vyjádření.

static constexpr int max_digits10 = 0;

Návratová hodnota

Vrátí počet desetinných číslic, které jsou požadovány k zajištění, že dvě odlišné hodnoty typu mají odlišné desítkové reprezentace.

Poznámky

Člen uloží počet desetinných míst potřebných k tomu, aby se zajistilo, že dvě odlišné hodnoty typu mají odlišné desítkové vyjádření.

max_exponent

Vrátí maximální kladnou celočíselnou exponent, kterou typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna radixu.

static constexpr int max_exponent = 0;

Návratová hodnota

Maximální celočíselný exponent založený na radixu reprezentovatelný typem.

Poznámky

Návrat členské funkce je smysluplný pouze pro typy s plovoucí desetinou čárkou. Jedná se max_exponent o hodnotu FLT_MAX_EXP pro typ float.

Příklad

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

Vrátí maximální kladnou celočíselnou exponent, kterou typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna deseti.

static constexpr int max_exponent10 = 0;

Návratová hodnota

Maximální celočíselný základ 10 exponent reprezentovatelný typem.

Poznámky

Návrat členské funkce je smysluplný pouze pro typy s plovoucí desetinou čárkou. Jedná se max_exponent o hodnotu FLT_MAX_10 pro typ float.

Příklad

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

Vrátí minimální normalizovanou hodnotu pro typ.

static constexpr Type min() throw();

Návratová hodnota

Minimální normalizovaná hodnota pro typ.

Poznámky

Minimální normalizovaná hodnota je INT_MIN pro typ int a FLT_MIN pro typ float. Návratová hodnota je smysluplná, pokud je true is_bounded nebo je-li is_signed false.

Příklad

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

Vrátí maximální záporný celočíselný exponent, který typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna radixu.

static constexpr int min_exponent = 0;

Návratová hodnota

Minimální celočíselný exponent založený na radixu reprezentovatelný typem.

Poznámky

Členová funkce je smysluplná pouze pro typy s plovoucí desetinou čárkou. Jedná se min_exponent o hodnotu FLT_MIN_EXP pro typ float.

Příklad

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

Vrátí maximální záporný celočíselný exponent, který typ s plovoucí desetinnou čárkou může představovat jako konečná hodnota, když je na tuto mocninu vyvolána základna deseti.

static constexpr int min_exponent10 = 0;

Návratová hodnota

Minimální celočíselný základ 10 exponent reprezentovatelný typem.

Poznámky

Členová funkce je smysluplná pouze pro typy s plovoucí desetinou čárkou. Jedná se min_exponent10 o hodnotu FLT_MIN_10_EXP pro typ float.

Příklad

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

Vrátí reprezentaci ticha, nikoli čísla (NAN) pro typ.

static constexpr Type quiet_NaN() throw();

Návratová hodnota

Reprezentace tichého názvu nan pro typ.

Poznámky

Návratová hodnota je smysluplná pouze v případě, že has_quiet_NaN je true.

Příklad

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

základ

Vrátí celočíselnou základnu, která se označuje jako radix, použitá pro reprezentaci typu.

static constexpr int radix = 0;

Návratová hodnota

Celočíselný základ pro reprezentaci typu.

Poznámky

Základ je 2 pro předdefinované celočíselné typy a základ, na který je exponent vyvolán nebo FLT_RADIX pro předdefinované typy s plovoucí desetinnou čárkou.

Příklad

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

Vrátí maximální chybu zaokrouhlení typu.

static constexpr Type round_error() throw();

Návratová hodnota

Maximální zaokrouhlovací chyba typu.

Příklad

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

Vrátí hodnotu, která popisuje různé metody, které implementace může zvolit pro zaokrouhlení hodnoty s plovoucí desetinou čárkou na celočíselnou hodnotu.

static constexpr float_round_style round_style = round_toward_zero;

Návratová hodnota

Hodnota z výčtu float_round_style , která popisuje styl zaokrouhlování.

Poznámky

Člen uloží hodnotu, která popisuje různé metody, které implementace může zvolit pro zaokrouhlení hodnoty s plovoucí desetinou čárkou na celočíselnou hodnotu.

Styl zaokrouhlení je pevně zakódován v této implementaci, takže i když program spustí jiný režim zaokrouhlování, tato hodnota se nezmění.

Příklad

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

Vrátí reprezentaci signálu, nikoli čísla (NAN) pro typ.

static constexpr Type signaling_NaN() throw();

Návratová hodnota

Reprezentace signalizačního NÁZVUN pro typ.

Poznámky

Návratová hodnota je smysluplná pouze v případě, že has_signaling_NaN je true.

Příklad

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

Testuje, zda typ může určit, že hodnota je příliš malá, aby byla reprezentována jako normalizovaná hodnota před zaokrouhlení.

static constexpr bool tinyness_before = false;

Návratová hodnota

true pokud typ dokáže rozpoznat drobné hodnoty před zaokrouhlení; false pokud to nejde.

Poznámky

Typy, které můžou rozpoznat drobnost, byly zahrnuty jako možnost s reprezentací s plovoucí desetinnou čárkou IEC 559 a její implementace může ovlivnit některé výsledky.

Příklad

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

depeše

Testuje, zda je u typu implementováno zachytnutí, které hlásí aritmetické výjimky.

static constexpr bool traps = false;

Návratová hodnota

true je-li pro typ implementováno zachytávání; false pokud tomu tak není.

Příklad

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

Sdílet prostřednictvím

numeric_limits – třída

Syntaxe

Parametry

Poznámky

Statické funkce a konstanty

denorm_min

Návratová hodnota

Poznámky

Příklad

číslice

Návratová hodnota

Poznámky

Příklad

číslice10

Návratová hodnota

Příklad

epsilon

Návratová hodnota

Poznámky

Příklad

has_denorm

Návratová hodnota

Poznámky

Příklad

has_denorm_loss

Návratová hodnota

Poznámky

Příklad

has_infinity

Návratová hodnota

Poznámky

Příklad

has_quiet_NaN

Návratová hodnota

Poznámky

Příklad

has_signaling_NaN

Návratová hodnota

Poznámky

Příklad

nekonečno

Návratová hodnota

Poznámky

Příklad

is_bounded

Návratová hodnota

Poznámky

Příklad

is_exact

Návratová hodnota

Poznámky

Příklad

is_iec559

Návratová hodnota

Poznámky

Příklad

is_integer

Návratová hodnota

Poznámky

Příklad

is_modulo

Návratová hodnota

Poznámky

Příklad

is_signed

Návratová hodnota

Poznámky

Příklad

is_specialized

Návratová hodnota

Poznámky

Příklad

nejnižší

Návratová hodnota

Poznámky

max

Návratová hodnota

Poznámky

Příklad