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;
};