Namespaces
Variants

std:: numeric_limits

From cppreference.net
Utilities library
Definiert in Header <limits>
template < class T > class numeric_limits ;

Die std::numeric_limits Klassenvorlage bietet eine standardisierte Möglichkeit, verschiedene Eigenschaften arithmetischer Typen abzufragen (z.B. der größtmögliche Wert für den Typ int ist std :: numeric_limits < int > :: max ( ) ).

Diese Informationen werden über Spezialisierungen der std::numeric_limits -Vorlage bereitgestellt. Die Standardbibliothek stellt Spezialisierungen für alle arithmetischen Typen bereit (listet nur die Spezialisierungen für cv-unqualifizierte arithmetische Typen auf):

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
Definiert im Header <limits>
template <> class numeric_limits < bool > ;
template <> class numeric_limits < char > ;
template <> class numeric_limits < signed char > ;
template <> class numeric_limits < unsigned char > ;
template <> class numeric_limits < wchar_t > ;
template <> class numeric_limits < char8_t > ;
(seit C++20)
template <> class numeric_limits < char16_t > ;
(seit C++11)
template <> class numeric_limits < char32_t > ;
(seit C++11)
template <> class numeric_limits < short > ;
template <> class numeric_limits < unsigned short > ;
template <> class numeric_limits < int > ;
template <> class numeric_limits < unsigned int > ;
template <> class numeric_limits < long > ;
template <> class numeric_limits < unsigned long > ;
template <> class numeric_limits < long long > ;
(seit C++11)
template <> class numeric_limits < unsigned long long > ;
(seit C++11)
template <> class numeric_limits < float > ;
template <> class numeric_limits < double > ;
template <> class numeric_limits < long double > ;

Der Wert jedes Members einer Spezialisierung von std::numeric_limits auf einem cv-qualifizierten Typ cv T ist gleich dem Wert des entsprechenden Members der Spezialisierung auf dem nicht qualifizierten Typ T . Zum Beispiel ist std :: numeric_limits < int > :: digits gleich std :: numeric_limits < const int > :: digits .

Aliases von arithmetischen Typen (wie std::size_t oder std::streamsize ) können ebenfalls mit den std::numeric_limits Type-Traits untersucht werden.

Nicht-arithmetische Standardtypen, wie std:: complex < T > oder std::nullptr_t , besitzen keine Spezialisierungen.

Falls die Implementierung integer-class types definiert, müssen auch Spezialisierungen von std::numeric_limits für diese bereitgestellt werden.

(since C++20)

Implementierungen können Spezialisierungen von std::numeric_limits für implementationsspezifische Typen bereitstellen: z.B. GCC bietet std::numeric_limits<__int128> . Nicht-standardisierte Bibliotheken können Spezialisierungen hinzufügen für bibliotheksbereitgestellte Typen, z.B. OpenEXR bietet std::numeric_limits<half> für einen 16-Bit-Gleitkommatyp.

Inhaltsverzeichnis

Template-Parameter

T - ein Typ, für den numerische Eigenschaften abgerufen werden sollen

Memberkonstanten

identifiziert Typen, für die std::numeric_limits spezialisiert ist
(öffentliche statische Member-Konstante)
[static]
identifiziert vorzeichenbehaftete Typen
(öffentliche statische Memberkonstante)
[static]
identifiziert Ganzzahltypen
(öffentliche statische Member-Konstante)
[static]
identifiziert exakte Typen
(öffentliche statische Member-Konstante)
identifiziert Gleitkommatypen, die den speziellen Wert "positive infinity" darstellen können
(öffentliche statische Member-Konstante)
identifiziert Gleitkommatypen, die den speziellen Wert "ruhendes Not-a-Number" (NaN) darstellen können
(öffentliche statische Member-Konstante)
kennzeichnet Gleitkommatypen, die den speziellen Wert "signaling not-a-number" (NaN) darstellen können
(öffentliche statische Member-Konstante)
[static]
identifiziert den Denormalisierungsstil, der vom Gleitkommatyp verwendet wird
(öffentliche statische Member-Konstante)
identifiziert die Gleitkommatypen, die Genauigkeitsverlust als Denormalisierungsverlust statt als ungenaues Ergebnis erkennen
(öffentliche statische Memberkonstante)
[static]
identifiziert den Rundungsstil, der vom Typ verwendet wird
(öffentliche statische Member-Konstante)
[static]
identifiziert die IEC 559/IEEE 754 Gleitkommatypen
(öffentliche statische Memberkonstante)
[static]
identifiziert Typen, die eine endliche Menge von Werten repräsentieren
(öffentliche statische Member-Konstante)
[static]
identifiziert Typen, die Überläufe mit Modulo-Arithmetik behandeln
(öffentliche statische Member-Konstante)
[static]
Anzahl der radix Ziffern, die ohne Änderung dargestellt werden können
(öffentliche statische Member-Konstante)
[static]
Anzahl der Dezimalstellen, die ohne Änderung dargestellt werden können
(öffentliche statische Member-Konstante)
[static] (C++11)
Anzahl der Dezimalstellen, die notwendig sind, um alle Werte dieses Typs zu unterscheiden
(öffentliche statische Member-Konstante)
[static]
die Basis oder Ganzzahlbasis, die für die Darstellung des gegebenen Typs verwendet wird
(öffentliche statische Member-Konstante)
Eins mehr als die kleinste negative Potenz der Basis, die einen gültigen normalisierten Gleitkommawert darstellt
(öffentliche statische Member-Konstante)
die kleinste negative Zehnerpotenz, die ein gültiger normalisierter Gleitkommawert ist
(öffentliche statische Member-Konstante)
Eins mehr als die größte ganzzahlige Potenz der Basis, die einen gültigen endlichen Gleitkommawert darstellt
(öffentliche statische Member-Konstante)
der größte ganzzahlige Exponent zur Basis 10, der einen gültigen endlichen Gleitkommawert darstellt
(öffentliche statische Member-Konstante)
[static]
identifiziert Typen, die Arithmetikoperationen zum Abfangen veranlassen können
(öffentliche statische Member-Konstante)
identifiziert Gleitkommatypen, die Tinyness vor dem Runden erkennen
(öffentliche statische Member-Konstante)

Memberfunktionen

[static]
gibt den kleinsten endlichen Wert des gegebenen Nicht-Gleitkommatyps zurück, oder den kleinsten positiven Normalwert des gegebenen Gleitkommatyps
(öffentliche statische Elementfunktion)
[static] (C++11)
gibt den niedrigsten endlichen Wert des gegebenen Typs zurück, d.h. den negativsten Wert für vorzeichenbehaftete Typen, 0 für vorzeichenlose Typen
(öffentliche statische Elementfunktion)
[static]
gibt den größten endlichen Wert des gegebenen Typs zurück
(öffentliche statische Elementfunktion)
[static]
gibt die Differenz zwischen 1.0 und dem nächsten darstellbaren Wert des gegebenen Gleitkommatyps zurück
(öffentliche statische Elementfunktion)
[static]
gibt den maximalen Rundungsfehler des gegebenen Gleitkommatyps zurück
(öffentliche statische Elementfunktion)
[static]
gibt den positiven Unendlichkeitswert des gegebenen Gleitkommatyps zurück
(öffentliche statische Elementfunktion)
[static]
gibt einen stillen NaN-Wert des gegebenen Gleitkommatyps zurück
(öffentliche statische Elementfunktion)
gibt einen signalisierenden NaN-Wert des gegebenen Gleitkommatyps zurück
(öffentliche statische Elementfunktion)
[static]
gibt den kleinsten positiven subnormalen Wert des gegebenen Gleitkommatyps zurück
(öffentliche statische Elementfunktion)

Hilfsklassen

kennzeichnet Gleitkomma-Rundungsmodi
(enum)
kennzeichnet Gleitkomma-Denormalisierungsmodi
(enum)

Beziehung zu C-Bibliotheks-Makrokonstanten

**Anmerkung:** Da der Text innerhalb der ` ` Tags C++-Code enthält und gemäß den Anweisungen nicht übersetzt werden soll, bleibt der gesamte Inhalt unverändert. Die C++-Schlüsselwörter `bool`, `false`, `true` und die numerische Konstante `2` wurden nicht übersetzt, wie gefordert.
Spezialisierung
std::numeric_limits<T>
wobei T ist
Member
min() lowest()
(C++11)
max() radix
bool false false true 2
char CHAR_MIN CHAR_MIN CHAR_MAX 2
signed char SCHAR_MIN SCHAR_MIN SCHAR_MAX 2
unsigned char 0 0 UCHAR_MAX 2
wchar_t WCHAR_MIN WCHAR_MIN WCHAR_MAX 2
char8_t 0 0 UCHAR_MAX 2
char16_t 0 0 UINT_LEAST16_MAX 2
char32_t 0 0 UINT_LEAST32_MAX 2
short SHRT_MIN SHRT_MIN SHRT_MAX 2
signed short
unsigned short 0 0 USHRT_MAX 2
int INT_MIN INT_MIN INT_MAX 2
signed int
unsigned int 0 0 UINT_MAX 2
long LONG_MIN LONG_MIN LONG_MAX 2
signed long
unsigned long 0 0 ULONG_MAX 2
long long LLONG_MIN LLONG_MIN LLONG_MAX 2
signed long long
unsigned long long 0 0 ULLONG_MAX 2
Spezialisierung
std::numeric_limits<T>
wobei T ist
Member
denorm_min() min() lowest()
(C++11)
max() epsilon() digits digits10
float FLT_TRUE_MIN FLT_MIN - FLT_MAX FLT_MAX FLT_EPSILON FLT_MANT_DIG FLT_DIG
double DBL_TRUE_MIN DBL_MIN - DBL_MAX DBL_MAX DBL_EPSILON DBL_MANT_DIG DBL_DIG
long double LDBL_TRUE_MIN LDBL_MIN - LDBL_MAX LDBL_MAX LDBL_EPSILON LDBL_MANT_DIG LDBL_DIG
Spezialisierung
std::numeric_limits<T>
wobei T ist
Mitglieder (Fortsetzung)
min_exponent min_exponent10 max_exponent max_exponent10 radix
float FLT_MIN_EXP FLT_MIN_10_EXP FLT_MAX_EXP FLT_MAX_10_EXP FLT_RADIX
double DBL_MIN_EXP DBL_MIN_10_EXP DBL_MAX_EXP DBL_MAX_10_EXP FLT_RADIX
long double LDBL_MIN_EXP LDBL_MIN_10_EXP LDBL_MAX_EXP LDBL_MAX_10_EXP FLT_RADIX

Beispiel

#include <iostream>
#include <limits>
int main() 
{
    std::cout << "type\t│ lowest()\t│ min()\t\t│ max()\n"
              << "bool\t│ "
              << std::numeric_limits<bool>::lowest() << "\t\t│ "
              << std::numeric_limits<bool>::min() << "\t\t│ "
              << std::numeric_limits<bool>::max() << '\n'
              << "uchar\t│ "
              << +std::numeric_limits<unsigned char>::lowest() << "\t\t│ "
              << +std::numeric_limits<unsigned char>::min() << "\t\t│ "
              << +std::numeric_limits<unsigned char>::max() << '\n'
              << "int\t│ "
              << std::numeric_limits<int>::lowest() << "\t│ "
              << std::numeric_limits<int>::min() << "\t│ "
              << std::numeric_limits<int>::max() << '\n'
              << "float\t│ "
              << std::numeric_limits<float>::lowest() << "\t│ "
              << std::numeric_limits<float>::min() << "\t│ "
              << std::numeric_limits<float>::max() << '\n'
              << "double\t│ "
              << std::numeric_limits<double>::lowest() << "\t│ "
              << std::numeric_limits<double>::min() << "\t│ "
              << std::numeric_limits<double>::max() << '\n';
}

Mögliche Ausgabe:

type	│ lowest()	│ min()		│ max()
bool	│ 0		│ 0		│ 1
uchar	│ 0		│ 0		│ 255
int	│ -2147483648	│ -2147483648	│ 2147483647
float	│ -3.40282e+38	│ 1.17549e-38	│ 3.40282e+38
double	│ -1.79769e+308	│ 2.22507e-308	│ 1.79769e+308

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 201 C++98 Spezialisierungen für alle grundlegenden Typen müssen bereitgestellt werden Nicht-arithmetische Typen ausgeschlossen
LWG 559 C++98 Es war unklar, ob die std::numeric_limits
Spezialisierung für einen cv-qualifizierten Typ sich genauso verhält
wie die entsprechende Spezialisierung für den cv-unqualifizierten Typ
Sie haben das
gleiche Verhalten

Siehe auch