std::numeric_limits

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Typunterstützung

Basistypen
Ganzzahltypen mit fester Breite (C++11)
Gleitkommatypen mit fester Breite (C++23)
ptrdiff_t size_t max_align_t (C++11)     byte (C++17)	nullptr_t (C++11) offsetof NULL
Numerische Grenzwerte
numeric_limits
C-Schnittstelle für numerische Grenzwerte
Laufzeit-Typinformationen
type_info type_index (C++11)	bad_typeid bad_cast

 

std::numeric_limits

Statische Konstanten

numeric_limits::is_specialized

numeric_limits::is_signed

numeric_limits::is_integer

numeric_limits::is_exact

numeric_limits::has_infinity

numeric_limits::has_quiet_NaN

numeric_limits::has_signaling_NaN

numeric_limits::has_denorm

numeric_limits::has_denorm_loss

numeric_limits::round_style

numeric_limits::is_iec559

numeric_limits::is_bounded

numeric_limits::is_modulo

numeric_limits::digits

numeric_limits::digits10

numeric_limits::max_digits10 (C++11)

numeric_limits::radix

numeric_limits::min_exponent

numeric_limits::min_exponent10

numeric_limits::max_exponent

numeric_limits::max_exponent10

numeric_limits::traps

numeric_limits::tinyness_before

Statische Member-Funktionen

numeric_limits::min

numeric_limits::lowest (C++11)

numeric_limits::max

numeric_limits::epsilon

numeric_limits::round_error

numeric_limits::infinity

numeric_limits::quiet_NaN

numeric_limits::signaling_NaN

numeric_limits::denorm_min

Hilfstypen

float_round_style

float_denorm_style

 

Definiert in Header <limits>
template< class T > class numeric_limits;

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

Diese Information wird über Spezialisierungen der Template-Klasse std::numeric_limits bereitgestellt. Die Standardbibliothek stellt Spezialisierungen für alle arithmetischen Typen zur Verfügung (hier werden nur die Spezialisierungen für cv-unqualifizierte arithmetische Typen aufgeführt).

Definiert in 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 Elements einer Spezialisierung von std::numeric_limits für einen cv-qualifizierten Typ cv T ist gleich dem Wert des entsprechenden Elements der Spezialisierung für den unqualifizierten Typ T. Zum Beispiel ist std::numeric_limits<int>::digits gleich std::numeric_limits<const int>::digits.

Aliase von arithmetischen Typen (wie z.B. std::size_t oder std::streamsize) können ebenfalls mit den std::numeric_limits Typ-Traits untersucht werden.

Standardtypen, die keine arithmetischen Typen sind, wie z.B. std::complex<T> oder std::nullptr_t, haben keine Spezialisierungen.

Wenn die Implementierung Integer-ähnliche Typen definiert, müssen auch für diese Spezialisierungen von std::numeric_limits bereitgestellt werden.

(seit C++20)

Implementierungen können Spezialisierungen von std::numeric_limits für implementierungsspezifische Typen bereitstellen: z.B. stellt GCC std::numeric_limits<__int128> bereit. Nicht-Standardbibliotheken können Spezialisierungen hinzufügen für von der Bibliothek bereitgestellte Typen, z.B. stellt OpenEXR std::numeric_limits<half> für einen 16-Bit-Gleitkommatyp bereit.

Template-Parameter

T

-

ein Typ, für den numerische Eigenschaften abgefragt werden sollen

Member-Konstanten

is_specialized [static]	identifiziert Typen, für die std::numeric_limits spezialisiert ist (öffentliche statische Member-Konstante)
is_signed [static]	identifiziert vorzeichenbehaftete Typen (öffentliche statische Member-Konstante)
is_integer [static]	identifiziert Ganzzahltypen (öffentliche statische Member-Konstante)
is_exact [static]	identifiziert exakte Typen (öffentliche statische Member-Konstante)
has_infinity [static]	identifiziert Gleitkommatypen, die den speziellen Wert "positive Unendlichkeit" darstellen können (öffentliche statische Member-Konstante)
has_quiet_NaN [static]	identifiziert Gleitkommatypen, die den speziellen Wert "quiet not-a-number" (NaN) darstellen können (öffentliche statische Member-Konstante)
has_signaling_NaN [static]	identifiziert Gleitkommatypen, die den speziellen Wert "signaling not-a-number" (NaN) darstellen können (öffentliche statische Member-Konstante)
has_denorm [static]	identifiziert den Denormalisierungsstil, der vom Gleitkommatyp verwendet wird (öffentliche statische Member-Konstante)
has_denorm_loss [static]	identifiziert die Gleitkommatypen, die einen Präzisionsverlust als Denormalisierungsverlust und nicht als ungenaues Ergebnis erkennen (öffentliche statische Member-Konstante)
round_style [static]	identifiziert den Rundungsstil, der vom Typ verwendet wird (öffentliche statische Member-Konstante)
is_iec559 [static]	identifiziert die IEC 559/IEEE 754 Gleitkommatypen (öffentliche statische Member-Konstante)
is_bounded [static]	identifiziert Typen, die eine endliche Menge von Werten darstellen (öffentliche statische Member-Konstante)
is_modulo [static]	identifiziert Typen, die Überläufe mit Modulo-Arithmetik behandeln (öffentliche statische Member-Konstante)
digits [static]	Anzahl der radix-Ziffern, die ohne Änderung dargestellt werden können (öffentliche statische Member-Konstante)
digits10 [static]	Anzahl der Dezimalziffern, die ohne Änderung dargestellt werden können (öffentliche statische Member-Konstante)
max_digits10 [statisch] (C++11)	Anzahl der Dezimalziffern, die erforderlich sind, um alle Werte dieses Typs zu unterscheiden (öffentliche statische Member-Konstante)
radix [static]	die Basis oder der ganzzahlige Basiswert, der für die Darstellung des gegebenen Typs verwendet wird (öffentliche statische Member-Konstante)
min_exponent [static]	eins mehr als die kleinste negative Potenz der Basis, die ein gültiger normalisierter Gleitkommawert ist (öffentliche statische Member-Konstante)
min_exponent10 [static]	die kleinste negative Potenz von zehn, die ein gültiger normalisierter Gleitkommawert ist (öffentliche statische Member-Konstante)
max_exponent [static]	eins mehr als die größte ganzzahlige Potenz der Basis, die ein gültiger endlicher Gleitkommawert ist (öffentliche statische Member-Konstante)
max_exponent10 [static]	die größte ganzzahlige Potenz von 10, die ein gültiger endlicher Gleitkommawert ist (öffentliche statische Member-Konstante)
traps [static]	identifiziert Typen, die arithmetische Operationen zum Trappen bringen können (öffentliche statische Member-Konstante)
tinyness_before [static]	identifiziert Gleitkommatypen, die "tinyness" vor dem Runden erkennen (öffentliche statische Member-Konstante)

Member-Funktionen

min [static]	gibt den kleinsten endlichen Wert des gegebenen nicht-Gleitkommatyps oder den kleinsten positiven normalen Wert des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)
lowest [statisch] (C++11)	gibt den kleinsten endlichen Wert des gegebenen Typs zurück, d.h. den negativsten Wert für vorzeichenbehaftete Typen, ​0​ für vorzeichenlose Typen (öffentliche statische Member-Funktion)
max [static]	gibt den größten endlichen Wert des gegebenen Typs zurück (öffentliche statische Member-Funktion)
epsilon [static]	gibt die Differenz zwischen 1.0 und dem nächstgrößeren darstellbaren Wert des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)
round_error [static]	gibt den maximalen Rundungsfehler des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)
infinity [static]	gibt den positiven Unendlichkeitswert des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)
quiet_NaN [static]	gibt einen stillen NaN-Wert des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)
signaling_NaN [static]	gibt einen Signal-NaN-Wert des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)
denorm_min [static]	gibt den kleinsten positiven Subnormalwert des gegebenen Gleitkommatyps zurück (öffentliche statische Member-Funktion)

Hilfsklassen

float_round_style	zeigt Gleitkomma-Rundungsmodi an (enum)
float_denorm_style	zeigt Gleitkomma-Denormalisierungsmodi an (enum)

Beziehung zu C-Bibliotheksmakrokonstanten

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	Elemente (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

Führen Sie diesen Code aus

#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	Korrigiertes Verhalten
LWG 201	C++98	Spezialisierungen für alle fundamentalen 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 genauso verhält wie die entsprechende Spezialisierung für den cv-unqualifizierten Typ	sie haben das gleiche Verhalten

Siehe auch

• Ganzzahltypen mit fester Breite
• Arithmetische Typen
• Übersicht über das C++-Typsystem
• Typunterstützung (Basis-Typen, RTTI, Typ-Traits)
• C-Schnittstelle für numerische Grenzwerte