numeric_limits-Klasse

Artikel
10/12/2023

Die Klassenvorlage beschreibt arithmetische Eigenschaften integrierter numerischer Typen.

Syntax

template <class Type>
    class numeric_limits

Parameter

Typ
Der grundlegende Elementdatentyp, dessen Eigenschaften getestet, abgefragt oder festgelegt werden. Der Typ kann auch deklariert constwerden, volatileoder const volatile.

Hinweise

Die Kopfzeile definiert explizite Spezialisierungen für die Typen wchar_t, , bool, char, , signed char, unsigned char, short, longintunsigned intlong doublefloatunsigned longunsigned shortlong longunsigned long longdouble, und .char32_tchar16_t Für diese expliziten Spezialisierungen ist der Member numeric_limits::is_specialized gleich true, und alle relevanten Elemente haben sinnvolle Werte. Das Programm kann zusätzliche explizite Spezialisierungen bereitstellen. Die meisten Memberfunktionen der Klasse beschreiben oder testen mögliche Implementierungen von float.

Für eine beliebige Spezialisierung gibt es keine Member, die sinnvolle Werte haben. Ein Memberobjekt, das keinen sinnvollen Wert hat, speichert 0 (oder false), und eine Memberfunktion, die keinen sinnvollen Wert zurückgibt, gibt Type(0)zurück.

Statische Funktionen und Konstanten

Name	Beschreibung
denorm_min	Gibt den kleinsten denormalisierten Wert ungleich 0 zurück.
Ziffern	Gibt die Anzahl von Basisziffern zurück, die der Typ ohne Genauigkeitsverlust darstellen kann.
digits10	Gibt die Anzahl von Dezimalziffern zurück, die der Typ ohne Genauigkeitsverlust darstellen kann.
epsilon	Gibt die Differenz zwischen 1 und dem kleinsten Wert größer als 1 zurück, die der Datentyp darstellen kann.
has_denorm	Testet, ob ein Typ denormalisierte Werte unterstützt.
has_denorm_loss	Testet, ob ein Genauigkeitsverlust nicht als ungenaues Ergebnis, sondern als Denormalisierungsverlust erkannt wird.
has_infinity	Testet, ob ein Typ eine Darstellung für positive Unendlichkeit hat.
has_quiet_NaN	Testet, ob ein Typ eine Darstellung für eine stille und keine Zahl (NAN) aufweist, was nicht signalisiert wird.
has_signaling_NaN	Testet, ob ein Typ eine Darstellung für eine anzeigenden NaN (Not a Number) hat.
infinity	Die Darstellung für positive Unendlichkeit für einen Typ, sofern verfügbar.
is_bounded	Testet, ob die Menge von Werten, die ein Typ darstellen kann, endlich ist.
is_exact	Testet, ob die für einen Typ ausgeführten Berechnungen keine Rundungsfehler haben.
is_iec559	Testet, ob ein Typ den IEC 559-Standards entspricht.
is_integer	Testet, ob ein Typ eine Ganzzahldarstellung hat.
is_modulo	Testet, ob ein Typ eine Modulodarstellung hat.
is_signed	Testet, ob ein Typ eine vorzeichenbehaftete Darstellung hat.
is_specialized	Testet, ob ein Typ eine explizite Spezialisierung in der Klassenvorlage `numeric_limits`definiert hat.
lowest	Gibt den kleinsten negativen begrenzten Wert zurück.
max	Gibt den größten endlichen Wert für einen Typ zurück.
max_digits10	Gibt die Anzahl von Dezimalstellen zurück, die dazu erforderlich ist sicherzustellen, dass zwei unterschiedliche Werte des Typs unterschiedliche Dezimaldarstellungen haben.
max_exponent	Gibt den größten positiven ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis mit diesem Exponenten potenziert wird.
max_exponent10	Gibt den größten positiven ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis von zehn mit diesem Exponenten potenziert wird.
min	Gibt den kleinsten normalisierten Wert für einen Typ zurück.
min_exponent	Gibt den größten negativen ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis mit diesem Exponenten potenziert wird.
min_exponent10	Gibt den größten negativen ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis von zehn mit diesem Exponenten potenziert wird.
quiet_NaN	Gibt die Darstellung einer stillen NaN (Not a Number) für den Typ zurück.
Basis	Gibt die ganzzahlige Basis (als Radix bezeichnet) zurück, die für die Darstellung eines Typs verwendet wird.
round_error	Gibt den größten Rundungsfehler für den Typ zurück.
round_style	Gibt einen Wert zurück, der die verschiedenen Methoden beschreibt, die eine Implementierung für die Rundung eines Gleitkommawerts auf einen ganzzahligen Wert auswählen kann.
signaling_NaN	Gibt die Darstellung einer anzeigenden NaN (Not a Number) für den Typ zurück.
tinyness_before	Testet, ob ein Typ für einen Wert vor dessen Rundung ermitteln kann, ob der Wert zu klein ist, um als normalisierter Wert dargestellt zu werden.
traps	Testet, ob für einen Typ Auffangen, bei dem arithmetischen Ausnahmen gemeldet werden, implementiert ist.

denorm_min

Gibt den kleinsten denormalisierten Wert ungleich 0 zurück.

static constexpr Type denorm_min() throw();

Rückgabewert

Der kleinste denormalisierte Wert ungleich 0.

Hinweise

long double ist identisch mit double dem C++-Compiler.

Die Funktion gibt den Minimalwert für den Typ zurück, der mit "min " identisch ist, wenn has_denorm nicht gleich ist denorm_present.

Beispiel

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

Zahlen

Gibt die Anzahl von Basisziffern zurück, die der Typ ohne Genauigkeitsverlust darstellen kann.

static constexpr int digits = 0;

Rückgabewert

Die Anzahl von Basisziffern, die der Typ ohne Genauigkeitsverlust darstellen kann.

Hinweise

Der Member speichert die Anzahl der Basisziffern, die der Typ ohne Änderung darstellen kann. Dies ist die Anzahl der Bits außer den Vorzeichenbits für einen vordefinierten Ganzzahltyp, oder die Anzahl der Mantissaziffern für einen vordefinierten Gleitkommatyp.

Beispiel

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

Gibt die Anzahl von Dezimalziffern zurück, die der Typ ohne Genauigkeitsverlust darstellen kann.

static constexpr int digits10 = 0;

Rückgabewert

Die Anzahl von Dezimalziffern, die der Typ ohne Genauigkeitsverlust darstellen kann.

Beispiel

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

Die Funktion gibt die Differenz zwischen 1 und dem kleinsten Wert größer als 1 zurück, die der Datentyp darstellen kann.

static constexpr Type epsilon() throw();

Rückgabewert

Die Differenz zwischen 1 und dem kleinsten Wert größer als 1, die der Datentyp darstellen kann.

Hinweise

Der Wert ist FLT_EPSILON für typ float. epsilon ist für ein Typ die kleinste positive Gleitkommazahl N, sodass N + epsilon + N darstellbar ist.

Beispiel

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

Testet, ob ein Typ denormalisierte Werte unterstützt.

static constexpr float_denorm_style has_denorm = denorm_absent;

Rückgabewert

Ein Enumerationswert vom Typ const float_denorm_style, der angibt, ob der Typ denormalisierte Werte zulässt.

Hinweise

Das Element speichert denorm_present für einen Gleitkommatyp mit denormalisierten Werten, effektiv eine variable Anzahl von exponenten Bits.

Beispiel

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

Testet, ob ein Genauigkeitsverlust nicht als ungenaues Ergebnis, sondern als Denormalisierungsverlust erkannt wird.

static constexpr bool has_denorm_loss = false;

Rückgabewert

true wenn der Verlust der Genauigkeit als Denormalisierungsverlust erkannt wird; false Wenn nicht,.

Hinweise

Der Member speichert TRUE für einen Typ, der bestimmt, ob ein Wert Genauigkeit verloren hat, da er als denormalisiertes Ergebnis (klein, um als normalisierte Werte darstellen) bereitgestellt wird oder ungenau ist (nicht das gleiche Ergebnis, daher nicht Teil des Einschränkungen des Exponentenbereichs und der Genauigkeit), eine Option mit IEC 559 Gleitkommadarstellungen, die einige Ergebnisse beeinflussen können.

Beispiel

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

Testet, ob ein Typ eine Darstellung für positive Unendlichkeit hat.

static constexpr bool has_infinity = false;

Rückgabewert

true wenn der Typ eine Darstellung für positive Unendlichkeit hat; false Wenn nicht,.

Hinweise

Das Element gibt zurück true , wenn is_iec559 ist true.

Beispiel

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

Testet, ob ein Typ eine Darstellung für eine stille NaN (Not a Number) hat, also eine nicht anzeigende NaN.

static constexpr bool has_quiet_NaN = false;

Rückgabewert

true wenn der Typ eine Darstellung für einen ruhigen NAN hat, false wenn nicht.

Hinweise

Ein stilles NAN ist eine Codierung für keine Zahl, die das Vorhandensein in einem Ausdruck nicht signalisiert. Der Rückgabewert ist true , wenn is_iec559 "true" ist.

Beispiel

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

Testet, ob ein Typ eine Darstellung für eine anzeigenden NaN (Not a Number) hat.

static constexpr bool has_signaling_NaN = false;

Rückgabewert

true wenn der Typ eine Darstellung für ein signalierendes NAN hat; false Wenn nicht,.

Hinweise

Ein stilles NAN ist eine Codierung für keine Zahl, die das Vorhandensein in einem Ausdruck nicht signalisiert. Der Rückgabewert ist true , wenn is_iec559 "true" ist.

Beispiel

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

Die Darstellung für positive Unendlichkeit für einen Typ, sofern verfügbar.

static constexpr Type infinity() throw();

Rückgabewert

Die Darstellung für positive Unendlichkeit für einen Typ, sofern verfügbar.

Hinweise

Der Rückgabewert ist nur dann sinnvoll, wenn has_infinity ist true.

Beispiel

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

Testet, ob die Menge von Werten, die ein Typ darstellen kann, endlich ist.

static constexpr bool is_bounded = false;

Rückgabewert

true wenn der Typ über einen begrenzten Satz von darstellbaren Werten verfügt; false Wenn nicht,.

Hinweise

Alle vordefinierten Typen verfügen über einen begrenzten Satz von darstellbaren Werten und zurückgeben true.

Beispiel

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

Testet, ob die für einen Typ ausgeführten Berechnungen keine Rundungsfehler haben.

static constexpr bool is_exact = false;

Rückgabewert

true wenn die Berechnungen frei von Rundungsfehlern sind; false Wenn nicht,.

Hinweise

Alle vordefinierten ganzzahligen Typen weisen genaue Darstellungen für ihre Werte auf und geben diese zurück false. Eine rationale oder Festkommadarstellung wird auch als genau betrachtet, nicht aber eine Gleitkommadarstellung.

Beispiel

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

Testet, ob ein Typ den IEC 559-Standards entspricht.

static constexpr bool is_iec559 = false;

Rückgabewert

true wenn der Typ den IEC 559-Normen entspricht; false Wenn nicht,.

Hinweise

Der IEC 559 ist eine internationale Norm zur Darstellung von Gleitkommawerten und wird in den USA auch als IEEE 754 bezeichnet.

Beispiel

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

Testet, ob ein Typ eine Ganzzahldarstellung hat.

static constexpr bool is_integer = false;

Rückgabewert

true wenn der Typ eine ganzzahlige Darstellung aufweist; false Wenn nicht,.

Hinweise

Alle vordefinierten Integertypen haben eine ganzzahlige Darstellung.

Beispiel

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

Testet, ob ein Typ eine Modulodarstellung hat.

static constexpr bool is_modulo = false;

Rückgabewert

true wenn der Typ eine Modulodarstellung aufweist; false Wenn nicht,.

Hinweise

Eine Modulo-Repräsentation ist eine Repräsentation, bei der alle Ergebnisse durch eine Modulodivision reduziert zurückgegeben werden. Alle vordefinierten Integertypen haben eine ganzzahlige Darstellung.

Beispiel

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

Testet, ob ein Typ eine vorzeichenbehaftete Darstellung hat.

static constexpr bool is_signed = false;

Rückgabewert

true wenn der Typ über eine signierte Darstellung verfügt; false Wenn nicht,.

Hinweise

Der Member speichert TRUE für einen Typ, der eine signierte Darstellung hat. Dies ist der Fall für alle vordefinierten Gleitkomma- und signierten Integer-Typen.

Beispiel

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

Testet, ob ein Typ eine explizite Spezialisierung in der Klassenvorlage numeric_limitsdefiniert hat.

static constexpr bool is_specialized = false;

Rückgabewert

true wenn der Typ eine explizite Spezialisierung in der Klassenvorlage definiert hat; false Wenn nicht,.

Hinweise

Alle skalaren Typen außer Zeigern weisen eine explizite Spezialisierung auf, die für die Klassenvorlage numeric_limitsdefiniert ist.

Beispiel

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

Am niedrigsten

Gibt den kleinsten negativen begrenzten Wert zurück.

static constexpr Type lowest() throw();

Rückgabewert

Gibt den kleinsten negativen begrenzten Wert zurück.

Hinweise

Gibt den kleinsten negativen, endlichen Wert für den Typ zurück (der normalerweise min() für ganzzahlige Typen und -max() für Gleitkommatypen ist). Der Rückgabewert ist aussagekräftig, wenn is_boundedtrue ist.

max

Gibt den größten endlichen Wert für einen Typ zurück.

static constexpr Type max() throw();

Rückgabewert

Der größte endliche Wert für einen Typ.

Hinweise

Der maximale endliche Wert wird für Typ und FLT_MAX für Typ int floatINT_MAX. Der Rückgabewert ist sinnvoll, wenn is_bounded ist true.

Beispiel

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

Gibt die Anzahl von Dezimalstellen zurück, die dazu erforderlich ist sicherzustellen, dass zwei unterschiedliche Werte des Typs unterschiedliche Dezimaldarstellungen haben.

static constexpr int max_digits10 = 0;

Rückgabewert

Gibt die Anzahl von Dezimalstellen zurück, die dazu erforderlich ist sicherzustellen, dass zwei unterschiedliche Werte des Typs unterschiedliche Dezimaldarstellungen haben.

Hinweise

Der Member speichert die Anzahl von Dezimalstellen, die dazu erforderlich ist sicherzustellen, dass zwei unterschiedliche Werte des Typs unterschiedliche Dezimaldarstellungen haben.

max_exponent

Gibt den größten positiven ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis mit diesem Exponenten potenziert wird.

static constexpr int max_exponent = 0;

Rückgabewert

Der maximale ganzzahlige Basis-basierte Exponent, der vom Typ dargestellt werden kann.

Hinweise

Die Rückgabe der Memberfunktion ist nur für Gleitkommatypen relevant. Der max_exponent Wert FLT_MAX_EXP für den Typ float.

Beispiel

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

Gibt den größten positiven ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis von zehn mit diesem Exponenten potenziert wird.

static constexpr int max_exponent10 = 0;

Rückgabewert

Die maximale ganzzahlige Basis 10 Exponent darstellbar vom Typ.

Hinweise

Die Rückgabe der Memberfunktion ist nur für Gleitkommatypen relevant. Der max_exponent Wert FLT_MAX_10 für typ float.

Beispiel

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

Gibt den kleinsten normalisierten Wert für einen Typ zurück.

static constexpr Type min() throw();

Rückgabewert

Der kleinste normalisierte Wert für einen Typ.

Hinweise

Der normalisierte Mindestwert ist INT_MIN für Typ int und FLT_MIN für Typ float. Der Rückgabewert ist aussagekräftig, wenn is_boundedtrue oder is_signedfalse ist.

Beispiel

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

Gibt den größten negativen ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis mit diesem Exponenten potenziert wird.

static constexpr int min_exponent = 0;

Rückgabewert

Der minimale ganzzahlige Basis-basierte Exponent, der vom Typ dargestellt werden kann.

Hinweise

Die Memberfunktion ist nur für Gleitkommatypen relevant. Der min_exponent Wert FLT_MIN_EXP für den Typ float.

Beispiel

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

Gibt den größten negativen ganzzahligen Exponenten zurück, den der Gleitkommatyp als einen endlichen Wert darstellen kann, wenn eine Basis von zehn mit diesem Exponenten potenziert wird.

static constexpr int min_exponent10 = 0;

Rückgabewert

Der maximale ganzzahlige Basis 10 Exponent darstellbar vom Typ.

Hinweise

Die Memberfunktion ist nur für Gleitkommatypen relevant. Der min_exponent10 Wert FLT_MIN_10_EXP für den Typ float.

Beispiel

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

Gibt die Darstellung einer stillen NaN (Not a Number) für den Typ zurück.

static constexpr Type quiet_NaN() throw();

Rückgabewert

Die Darstellung einer stillen NaN für den Typ.

Hinweise

Der Rückgabewert ist nur dann sinnvoll, wenn has_quiet_NaN ist true.

Beispiel

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

Basis

Gibt die ganzzahlige Basis (als Radix bezeichnet) zurück, die für die Darstellung eines Typs verwendet wird.

static constexpr int radix = 0;

Rückgabewert

Die ganzzahlige Basis für die Darstellung des Typs.

Hinweise

Die Basis für die vordefinierten Integertypen ist 2 und die Basis, auf die der Exponent potenziert wird, oder FLT_RADIX, für die vordefinierten Gleitkommadatentypen.

Beispiel

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

Gibt den größten Rundungsfehler für den Typ zurück.

static constexpr Type round_error() throw();

Rückgabewert

Der größte Rundungsfehler für den Typ.

Beispiel

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

Gibt einen Wert zurück, der die verschiedenen Methoden beschreibt, die eine Implementierung für die Rundung eines Gleitkommawerts auf einen ganzzahligen Wert auswählen kann.

static constexpr float_round_style round_style = round_toward_zero;

Rückgabewert

Ein Wert aus der float_round_style-Enumeration, der den Rundungsmodus beschreibt.

Hinweise

Gibt einen Wert zurück, der die verschiedenen Methoden beschreibt, die eine Implementierung für die Rundung eines Gleitkommawerts auf einen ganzzahligen Wert auswählen kann.

Der Rundungsmodus ist fest in dieser Implementierung programmiert.Selbst wenn das Programm mit einem anderen Rundungsmodus gestartet wird, wird dieser Wert nicht geändert.

Beispiel

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

Gibt die Darstellung einer anzeigenden NaN (Not a Number) für den Typ zurück.

static constexpr Type signaling_NaN() throw();

Rückgabewert

Die Darstellung einer signalisierenden NaN für den Typ.

Hinweise

Der Rückgabewert ist nur dann sinnvoll, wenn has_signaling_NaN ist true.

Beispiel

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

Testet, ob ein Typ für einen Wert vor dessen Rundung ermitteln kann, ob der Wert zu klein ist, um als normalisierter Wert dargestellt zu werden.

static constexpr bool tinyness_before = false;

Rückgabewert

true, wenn der Typ kleine Werte vor der Rundung erkennen kann; false, wenn dies nicht möglich ist.

Hinweise

Typen, die Winzigkeiten erkennen können, wurden als Option mit IEC 559-Gleitkommadarstellungen eingeschlossen, und seine Implementierung kann einige Ergebnisse beeinflussen.

Beispiel

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

Testet, ob für einen Typ Auffangen, bei dem arithmetischen Ausnahmen gemeldet werden, implementiert ist.

static constexpr bool traps = false;

Rückgabewert

true wenn Trapping für den Typ implementiert wird; false wenn nicht.

Beispiel

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

Teilen über

numeric_limits-Klasse

Syntax

Parameter

Hinweise

Statische Funktionen und Konstanten

denorm_min

Rückgabewert

Hinweise

Beispiel

Zahlen

Rückgabewert

Hinweise

Beispiel

digits10

Rückgabewert

Beispiel

epsilon

Rückgabewert

Hinweise

Beispiel

has_denorm

Rückgabewert

Hinweise

Beispiel

has_denorm_loss

Rückgabewert

Hinweise

Beispiel

has_infinity

Rückgabewert

Hinweise

Beispiel

has_quiet_NaN

Rückgabewert

Hinweise

Beispiel

has_signaling_NaN

Rückgabewert

Hinweise

Beispiel

infinity

Rückgabewert

Hinweise

Beispiel

is_bounded

Rückgabewert

Hinweise

Beispiel

is_exact

Rückgabewert

Hinweise

Beispiel

is_iec559

Rückgabewert

Hinweise

Beispiel

is_integer

Rückgabewert

Hinweise

Beispiel

is_modulo

Rückgabewert

Hinweise

Beispiel

is_signed

Rückgabewert

Hinweise

Beispiel

is_specialized

Rückgabewert

Hinweise

Beispiel

Am niedrigsten

Rückgabewert

Hinweise

max

Rückgabewert

Hinweise

Beispiel