std:: numeric_limits
|
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):
|
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
|
(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
|
[static]
|
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) |
|
[static]
|
identifiziert Gleitkommatypen, die den speziellen Wert "positive infinity" darstellen können
(öffentliche statische Member-Konstante) |
|
[static]
|
identifiziert Gleitkommatypen, die den speziellen Wert "ruhendes Not-a-Number" (NaN) darstellen können
(öffentliche statische Member-Konstante) |
|
[static]
|
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) |
|
[static]
|
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) |
|
[static]
|
Eins mehr als die kleinste negative Potenz der Basis, die einen gültigen normalisierten Gleitkommawert darstellt
(öffentliche statische Member-Konstante) |
|
[static]
|
die kleinste negative Zehnerpotenz, die ein gültiger normalisierter Gleitkommawert ist
(öffentliche statische Member-Konstante) |
|
[static]
|
Eins mehr als die größte ganzzahlige Potenz der Basis, die einen gültigen endlichen Gleitkommawert darstellt
(öffentliche statische Member-Konstante) |
|
[static]
|
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) |
|
[static]
|
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) |
|
[static]
|
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
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 |