C ++ - Bibliothek - <Limits>

Einführung

Es handelt sich um einen numerischen Grenzwerttyp, der Informationen zu den Eigenschaften von arithmetischen Typen (entweder Integral oder Gleitkomma) in der spezifischen Plattform enthält, für die die Bibliothek kompiliert wird.

Erklärung

Es folgt die Deklaration für std :: numeric_limits.

template <class T> numeric_limits;

C ++ 11

template <class T> numeric_limits;

Parameter

T - Es ist eine Art Klasse.

Beispiel

Im folgenden Beispiel für std :: numeric_limits.

#include <limits>
#include <iostream>

int main() {
   std::cout << "type\tlowest type\thighest type\n";
   std::cout << "int\t"
      << std::numeric_limits<int>::lowest() << '\t'
      << std::numeric_limits<int>::max() << '\n';
   std::cout << "float\t"
      << std::numeric_limits<float>::lowest() << '\t'
      << std::numeric_limits<float>::max() << '\n';
   std::cout << "double\t"
      << std::numeric_limits<double>::lowest() << '\t'
      << std::numeric_limits<double>::max() << '\n';
}

Die Beispielausgabe sollte folgendermaßen aussehen:

type	lowest type	highest type
int	-2147483648	2147483647
float	-3.40282e+38	3.40282e+38
double	-1.79769e+308	1.79769e+308

Vorlageninstanziierungen

Die grundlegenden arithmetischen Typen von C ++ 98 sollten wie folgt aussehen:

grundlegende arithmetische Typen
integrale Typen bool
char
wchar_t
signed char
short int
int
long int
unsigned char
unsigned short int
unsigned int
unsigned long int
Gleitkommatypen float
double
long double

Die grundlegenden arithmetischen Typen von C ++ 11 sollten wie folgt aussehen:

grundlegende arithmetische Typen
integrale Typen bool
char
char16_t
char32_t
wchar_t
signed char
short int
int
long int
long long int
unsigned char
unsigned short int
unsigned int
unsigned long int
unsigned long long int
Gleitkommatypen float
double
long double

Mitglieder

Mitglied Art Eigentum
is_specialized bool Es ist truefür alle (dh für diejenigen, für dienumeric_limitsist spezialisiert). und falsefür alle anderen Typen.
Mindest() T.

Es ist ein minimaler endlicher Wert.

Für Floating-Typen mit Denormalisierung (variable Anzahl von Exponentenbits): minimaler positiver normalisierter Wert.

Gleichwertig CHAR_MIN, SCHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, BL_MIN, LDBL_MINoder 0je nach Typ.

max () T.

Es ist ein maximaler endlicher Wert.

Gleichwertig CHAR_MAX, SCHAR_MAX, UCHAR_MAX, SHRT_MAX, USHRT_MAX, INT_MAX, UINT_MAX, LONG_MAX, ULONG_MAX, LLONG_MAX, ULLONG_MAX, UINT_LEAST16_MAX, UINT_LEAST32_MAX, FLT_MAX, DBL_MAX oder LDBL_MAX, je nach Typ.

niedrigste () T.

Es ist ein minimaler endlicher Wert. (seit C ++ 11)

Für integrale Typen: das gleiche wie Mindest().

Für Gleitkommatypen: implementierungsabhängig; im Allgemeinen ist das Negativ vonmax ().

Ziffern int

Dies gilt für ganzzahlige Typen: Anzahl der nicht vorzeichenbehafteten Bits ( Radix- Basisziffern) in der Darstellung.

Für schwebende Typen: Anzahl der Stellen (in Radix- Basis) in der Mantisse (entsprichtFLT_MANT_DIG, DBL_MANT_DIG oder LDBL_MANT_DIG).

Ziffern10 int

Es ist eine Anzahl von Ziffern (in Dezimalbasis), die ohne Änderung dargestellt werden können.

Gleichwertig FLT_DIG, DBL_DIG oder LDBL_DIG für schwimmende Typen.

max_digits10 int Es ist eine Anzahl von Ziffern (in Dezimalbasis), die erforderlich sind, um sicherzustellen, dass unterschiedliche Werte immer differenziert werden.
is_signed bool true wenn Typ signiert ist.
is_integer bool true Wenn der Typ eine Ganzzahl ist.
is_exact bool true Wenn der Typ genaue Darstellungen verwendet.
radix int

Es ist für ganzzahlige Typen: Basis der Darstellung.

Für schwebende Typen: Basis des Exponenten der Darstellung (entspricht FLT_RADIX).

Epsilon() T.

Es ist ein Maschinen-Epsilon (die Differenz zwischen 1 und dem kleinsten Wert größer als 1, der darstellbar ist).

Gleichwertig FLT_EPSILON, DBL_EPSILON oder LDBL_EPSILON für schwimmende Typen.

round_error () T. Es misst den maximalen Rundungsfehler.
min_exponent int

Es ist ein minimaler negativer ganzzahliger Wert, so dass der Radix erhöht wird, (min_exponent-1)um eine normalisierte Gleitkommazahl zu erzeugen.

Gleichwertig FLT_MIN_EXP, DBL_MIN_EXP oder LDBL_MIN_EXP für schwimmende Typen.

min_exponent10 int

Es ist ein minimaler negativer ganzzahliger Wert, so dass 10, die auf diese Potenz angehoben werden, eine normalisierte Gleitkommazahl erzeugen.

Gleichwertig FLT_MIN_10_EXP, DBL_MIN_10_EXP oder LDBL_MIN_10_EXP für schwimmende Typen.

max_exponent int

Es ist ein maximaler ganzzahliger Wert, bei dem der Radix erhöht wird, (max_exponent-1)um eine darstellbare endliche Gleitkommazahl zu erzeugen.

Gleichwertig FLT_MAX_EXP, DBL_MAX_EXP oder LDBL_MAX_EXP für schwimmende Typen.

max_exponent10 int

Es ist ein maximaler ganzzahliger Wert, so dass 10, die auf diese Potenz angehoben werden, eine normalisierte endliche Gleitkommazahl erzeugen.

Gleichwertig FLT_MAX_10_EXP, DBL_MAX_10_EXP oder LDBL_MAX_10_EXP für schwimmende Typen.

has_infinity bool true wenn der Typ eine Darstellung für positive Unendlichkeit hat.
has_quiet_NaN bool true wenn der Typ eine Darstellung für ein leises (nicht signalisierendes) "Not-a-Number" hat.
has_signaling_NaN bool true wenn der Typ eine Darstellung für eine Signalisierung "Not-a-Number" hat.
has_denorm float_denorm_style

Es handelt sich um denormalisierte Werte (Darstellungen mit einer variablen Anzahl von Exponentenbits). Ein Typ kann einen der folgenden Aufzählungswerte haben:

denorm_absent, wenn es keine denormalisierten Werte zulässt.

denorm_present, wenn es denormalisierte Werte zulässt.

denorm_indeterminate, wenn zur Kompilierungszeit unbestimmt.

has_denorm_loss bool truewenn ein Genauigkeitsverlust als Denormalisierungsverlust und nicht als ungenaues Ergebnis erkannt wird.
Unendlichkeit() T. Es steht für positive Unendlichkeit , falls verfügbar.
quiet_NaN () T. Es steht für leises (nicht signalisierendes) "Not-a-Number" , falls verfügbar.
signalisierung_NaN () T. Es handelt sich um die Signalisierung "Not-a-Number" , falls verfügbar.
denorm_min () T.

Minimaler positiver denormalisierter Wert.

Dies gilt für Typen, die keine denormalisierten Werte zulassen: wie min().

is_iec559 bool

true wenn der Typ der Norm IEC-559 / IEEE-754 entspricht.

Ein IEC-559-Typ hat immer has_infinity, has_quiet_NaN und has_signaling_NaNsetzen auf true; UndUnendlichkeit, quiet_NaN und signalisierung_NaN einen Wert ungleich Null zurückgeben.

ist begrenzt bool true wenn die durch den Typ dargestellte Wertemenge endlich ist.
is_modulo bool truewenn der Typ Modulo ist. Ein Typ ist modulo, wenn es möglich ist, zwei positive Zahlen hinzuzufügen und ein Ergebnis zu erhalten, das sich um eine dritte Zahl dreht, die kleiner ist.
Fallen bool true wenn für den Typ eine Überfüllung implementiert ist.
tinyness_before bool true wenn vor dem Runden eine Zinnheit festgestellt wird.
round_style float_round_style

Es ist ein Rundungsstil. Ein Typ kann einen der folgenden Aufzählungswerte haben:

round_toward_zero, wenn es gegen Null rundet.

round_to_nearest, wenn es auf den nächsten darstellbaren Wert rundet.

round_toward_infinity, wenn es gegen unendlich rundet.

round_toward_neg_infinity, wenn es in Richtung negative Unendlichkeit rundet.

round_indeterminate, wenn der Rundungsstil zur Kompilierungszeit nicht bestimmbar ist.

Für alle oben genannten Typen, die keine grundlegenden arithmetischen Typen sind, wird die Standardvorlagendefinition verwendet -

C ++ 98

template <class T> class numeric_limits {
   public:
      static const bool is_specialized = false;
      static T min() throw();
      static T max() throw();
      static const int digits = 0;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 0;
      static T epsilon() throw();
      static T round_error() throw();

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm = denorm_absent;
      static const bool has_denorm_loss = false;
      static T infinity() throw();
      static T quiet_NaN() throw();
      static T signaling_NaN() throw();
      static T denorm_min() throw();

      static const bool is_iec559 = false;
      static const bool is_bounded = false;
      static const bool is_modulo = false;

      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
};

C ++ 11

template <class T> class numeric_limits {
   public:
      static constexpr bool is_specialized = false;
      static constexpr T min() noexcept { return T(); }
      static constexpr T max() noexcept { return T(); }
      static constexpr T lowest() noexcept { return T(); }
      static constexpr int digits = 0;
      static constexpr int digits10 = 0;
      static constexpr bool is_signed = false;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 0;
      static constexpr T epsilon() noexcept { return T(); }
      static constexpr T round_error() noexcept { return T(); }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;
      static constexpr T infinity() noexcept { return T(); }
      static constexpr T quiet_NaN() noexcept { return T(); }
      static constexpr T signaling_NaN() noexcept { return T(); }
      static constexpr T denorm_min() noexcept { return T(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = false;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before = false;
};