Namespaces
Variants

    std::numeric_limits

    Aus de.cppreference.net
     
    C++
     
    Hilfsbibliothek
    Sprachunterstützung
    Typunterstützung (grundlegende Typen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Hilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Coroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationale Operatoren (veraltet in C++20)
    Integer-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Typunterstützung
    Grundlegende Typen
    Ganzzahltypen mit fester Breite (C++11)
    Gleitkommatypen mit fester Breite (C++23)
    (C++11)    
    (C++17)
    Numerische Grenzwerte
    C-Numerik-Grenzwerte-Schnittstelle
    Laufzeit-Typinformationen
     
    std::numeric_limits
    Statische Konstanten
    (C++11)
    Statische Elementfunktionen
    (C++11)
    Hilfstypen
     
    Definiert in Header <limits> 
    template< class T > class numeric_limits;

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

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

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

    Aliase arithmetischer Typen (wie std::size_t oder std::streamsize) können ebenfalls mit den std::numeric_limits-Typmerkmalen untersucht werden.

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

    Falls die Implementierung integer-class types 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. bietet GCC std::numeric_limits<__int128>. Nicht standardkonforme Bibliotheken können Spezialisierungen hinzufügen für von der Bibliothek bereitgestellte Typen, z. B. OpenEXR bietet std::numeric_limits<half> für einen 16-Bit-Gleitkommatyp.

    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

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

    Diesen Code ausführen 
    #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