std::numeric_limits<T>:traps

 

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

 

static const bool traps;		(bis C++11)
static constexpr bool traps;		(seit C++11)

Der Wert von std::numeric_limits<T>::traps ist true für alle arithmetischen Typen T, die zu Beginn des Programms mindestens einen Wert haben, der, wenn er als Argument für eine arithmetische Operation verwendet wird, eine Trap (Ausnahmebedingung) erzeugt.

Standard-Spezialisierungen

T	Wert von std::numeric_limits<T>::traps
/* nicht spezialisiert */	false
bool	false
char	normalerweise true
signed char	normalerweise true
unsigned char	normalerweise true
wchar_t	normalerweise true
char8_t (seit C++20)	normalerweise true
char16_t (seit C++11)	normalerweise true
char32_t (seit C++11)	normalerweise true
short	normalerweise true
unsigned short	normalerweise true
int	normalerweise true
unsigned int	normalerweise true
long	normalerweise true
unsigned long	normalerweise true
long long (seit C++11)	normalerweise true
unsigned long long (seit C++11)	normalerweise true
float	normalerweise false
double	normalerweise false
long double	normalerweise false

Hinweise

Auf den meisten Plattformen löst die Ganzzahldivision durch Null immer eine Trap aus, und std::numeric_limits<T>::traps ist true für alle Ganzzahltypen, die den Wert ​0​ unterstützen. Die Ausnahme ist der Typ bool: Obwohl die Division durch false aufgrund der ganzzahligen Promotion von bool zu int eine Trap auslöst, ist es der Wert Null von int, der die Trap auslöst. Null ist kein Wert des Typs bool.

Auf den meisten Plattformen können Gleitkomma-Ausnahmen zur Laufzeit ein- und ausgeschaltet werden (z. B. feenableexcept() unter Linux oder _controlfp unter Windows). In diesem Fall spiegelt der Wert von std::numeric_limits<T>::traps für Gleitkommatypen den Zustand der Gleitkomma-Trap-Einrichtung zum Zeitpunkt des Programmstarts wider, der auf den meisten modernen Systemen false ist. Eine Ausnahme wäre ein DEC Alpha-Programm, bei dem er true ist, wenn es ohne -ieee kompiliert wird.

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <limits>
 
int main()
{
    std::cout << std::boolalpha
              << "bool:     traps = " << std::numeric_limits<bool>::traps << '\n'
              << "char:     traps = " << std::numeric_limits<char>::traps << '\n'
              << "char16_t: traps = " << std::numeric_limits<char16_t>::traps << '\n'
              << "long:     traps = " << std::numeric_limits<long>::traps << '\n'
              << "float:    traps = " << std::numeric_limits<float>::traps << '\n';
}

Mögliche Ausgabe

// GCC output:
bool:     traps = true
char:     traps = true
char16_t: traps = true
long:     traps = true
float:    traps = false
 
// Clang output:
bool:     traps = false
char:     traps = true
char16_t: traps = true
long:     traps = true
float:    traps = false

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 497	C++98	war unklar, was zurückgegeben wird, wenn eine Trap zur Laufzeit aktiviert oder deaktiviert ist	gibt den Aktivierungsstatus zurück zu Beginn des Programms

Siehe auch

Gleitkomma-Umgebung
tinyness_before [static]	identifiziert Gleitkommatypen, die "tinyness" vor dem Runden erkennen (ö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)