Bibliothèque C ++ - <limits>

introduction

Il s'agit d'un type de limites numériques et il fournit des informations sur les propriétés des types arithmétiques (intégraux ou à virgule flottante) dans la plate-forme spécifique pour laquelle la bibliothèque compile.

Déclaration

Voici la déclaration pour std :: numeric_limits.

template <class T> numeric_limits;

C ++ 11

template <class T> numeric_limits;

Paramètres

T - C'est un type de classe.

Exemple

Dans l'exemple ci-dessous pour 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';
}

L'exemple de sortie devrait être comme ceci -

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

Instanciations de modèle

Les types arithmétiques fondamentaux de C ++ 98 devraient être comme ceci -

types arithmétiques fondamentaux
types intégraux	bool
	char
	wchar_t
	signed char
	short int
	int
	long int
	unsigned char
	unsigned short int
	unsigned int
	unsigned long int
types à virgule flottante	float
	double
	long double

Les types arithmétiques fondamentaux de C ++ 11 devraient être comme ceci -

types arithmétiques fondamentaux
types intégraux	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
types à virgule flottante	float
	double
	long double

Membres

membre	type	propriété
est_spécialisé	bool	C'est truepour tous (c'est-à-dire ceux pour lesquelsnumeric_limitsest spécialisé). et falsepour tous les autres types.
min ()	T	C'est une valeur finie minimale. Pour les types flottants avec dénormalisation (nombre variable de bits d'exposant): valeur normalisée positive minimale. Équivalent à CHAR_MIN, SCHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, BL_MIN, LDBL_MINou 0, selon le type.
max ()	T	C'est une valeur finie maximale. Équivalent à 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 ou LDBL_MAX, selon le type.
le plus bas()	T	C'est une valeur finie minimale. (depuis C ++ 11) Pour les types intégraux: identique à min (). Pour les types à virgule flottante: dépend de l'implémentation; généralement, le négatif demax ().
chiffres	int	Il est pour les types d'entiers: nombre de bits non-SIGN ( radix chiffres de base) dans la représentation. Pour les types flottants: nombre de chiffres (en base de base) dans la mantisse (équivalent àFLT_MANT_DIG, DBL_MANT_DIG ou LDBL_MANT_DIG).
chiffres10	int	C'est un nombre de chiffres (en base décimale), qui peut être représenté sans changement. Équivalent à FLT_DIG, DBL_DIG ou LDBL_DIG pour les types flottants.
max_digits10	int	C'est un nombre de chiffres (en base décimale) qui est nécessaire pour garantir que les valeurs qui diffèrent sont toujours différenciées.
est_signé	bool	true si le type est signé.
is_integer	bool	true si le type est un entier.
is_exact	bool	true si le type utilise des représentations exactes.
base	int	C'est pour les types entiers: base de la représentation. Pour les types flottants: base de l'exposant de la représentation (équivalent à FLT_RADIX).
epsilon ()	T	C'est une machine epsilon (la différence entre 1 et la moindre valeur supérieure à 1 qui est représentable). Équivalent à FLT_EPSILON, DBL_EPSILON ou LDBL_EPSILON pour les types flottants.
round_error ()	T	Il mesure l'erreur d'arrondi maximale.
min_exponent	int	Il s'agit d'une valeur entière négative minimale telle que la base élevée à (min_exponent-1)génère un nombre à virgule flottante normalisé. Équivalent à FLT_MIN_EXP, DBL_MIN_EXP ou LDBL_MIN_EXP pour les types flottants.
min_exponent10	int	Il s'agit d'une valeur entière négative minimale telle que 10 élevée à cette puissance génère un nombre à virgule flottante normalisé. Équivalent à FLT_MIN_10_EXP, DBL_MIN_10_EXP ou LDBL_MIN_10_EXP pour les types flottants.
max_exponent	int	Il s'agit d'une valeur entière maximale telle que la base élevée à (max_exponent-1)génère un nombre à virgule flottante fini représentable. Équivalent à FLT_MAX_EXP, DBL_MAX_EXP ou LDBL_MAX_EXP pour les types flottants.
max_exponent10	int	C'est une valeur entière maximale telle que 10 élevée à cette puissance génère un nombre à virgule flottante fini normalisé. Équivalent à FLT_MAX_10_EXP, DBL_MAX_10_EXP ou LDBL_MAX_10_EXP pour les types flottants.
has_infinity	bool	true si le type a une représentation pour l'infini positif.
has_quiet_NaN	bool	true si le type a une représentation pour un "Not-a-Number" silencieux (sans signalisation).
has_signaling_NaN	bool	true si le type a une représentation pour une signalisation "Not-a-Number".
has_denorm	float_denorm_style	Il s'agit d'une valeur dénormalisée (représentations avec un nombre variable de bits d'exposant). Un type peut avoir l'une des valeurs d'énumération suivantes - denorm_absent, s'il n'autorise pas les valeurs dénormalisées. denorm_present, si elle autorise les valeurs dénormalisées. denorm_indeterminate, si indéterminé au moment de la compilation.
has_denorm_loss	bool	truesi une perte de précision est détectée comme une perte de dénormalisation, plutôt que comme un résultat inexact.
infini()	T	Il représente l' infini positif , s'il est disponible.
quiet_NaN ()	T	Il représente un "Not-a-Number" silencieux (sans signalisation) , s'il est disponible.
signalisation_NaN ()	T	Il représente la signalisation "Not-a-Number" , si disponible.
denorm_min ()	T	Valeur dénormalisée positive minimale. C'est pour les types n'autorisant pas les valeurs dénormalisées: idem min().
is_iec559	bool	true si le type est conforme à la norme IEC-559 / IEEE-754. Un type CEI-559 a toujours has_infinity, has_quiet_NaN et has_signaling_NaNmis à true; Etinfini, quiet_NaN et signalisation_NaN renvoie une valeur différente de zéro.
est délimité	bool	true si l'ensemble de valeurs représenté par le type est fini.
is_modulo	bool	truesi le type est modulo. Un type est modulo s'il est possible d'ajouter deux nombres positifs et d'avoir un résultat qui s'enroule autour d'un troisième nombre inférieur.
pièges	bool	true si le recouvrement est implémenté pour le type.
minuscule_avant	bool	true si une minuscule est détectée avant l'arrondi.
round_style	float_round_style	C'est un style arrondi. Un type peut avoir l'une des valeurs d'énumération suivantes - round_toward_zero, s'il arrondit vers zéro. round_to_nearest, s'il arrondit à la valeur représentable la plus proche. round_toward_infinity, s'il arrondit vers l'infini. round_toward_neg_infinity, s'il arrondit vers l'infini négatif. round_indeterminate, si le style d'arrondi est indéterminable au moment de la compilation.

Pour tous les types ci-dessus qui ne sont pas des types arithmétiques fondamentaux, la définition de modèle par défaut est utilisée -

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