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