Biblioteca C ++ - <límites>

Introducción

Es un tipo de límites numéricos y proporciona información sobre las propiedades de los tipos aritméticos (integrales o de punto flotante) en la plataforma específica para la que compila la biblioteca.

Declaración

A continuación se muestra la declaración de std :: numeric_limits.

template <class T> numeric_limits;

C ++ 11

template <class T> numeric_limits;

Parámetros

T - Es un tipo de clase.

Ejemplo

En el siguiente ejemplo para 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';
}

La salida de muestra debería ser así:

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

Instancias de plantilla

Los tipos aritméticos fundamentales de C ++ 98 deberían ser así:

tipos aritméticos fundamentales
tipos integrales	bool
	char
	wchar_t
	signed char
	short int
	int
	long int
	unsigned char
	unsigned short int
	unsigned int
	unsigned long int
tipos de coma flotante	float
	double
	long double

Los tipos aritméticos fundamentales de C ++ 11 deberían ser así:

tipos aritméticos fundamentales
tipos integrales	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
tipos de coma flotante	float
	double
	long double

Miembros

miembro	tipo	propiedad
is_specialized	bool	Es truepara todos (es decir, aquellos para los quelímites_numéricoses especializado). y falsepara todos los demás tipos.
min ()	T	Es un valor finito mínimo. Para tipos flotantes con desnormalización (número variable de bits de exponente): valor mínimo normalizado positivo. Equivalente a CHAR_MIN, SCHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, BL_MIN, LDBL_MINo 0, según el tipo.
max ()	T	Es un valor finito máximo. Equivalente a 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 o LDBL_MAX, dependiendo del tipo.
más bajo ()	T	Es un valor finito mínimo. (desde C ++ 11) Para tipos integrales: lo mismo que min (). Para tipos de coma flotante: dependiente de la implementación; en general, el negativo demax ().
digitos	En t	Es por tipos de enteros: número de bits no-SIGN ( radix dígitos de bases) en la representación. Para tipos flotantes: número de dígitos (en base a base) en la mantisa (equivalente aFLT_MANT_DIG, DBL_MANT_DIG o LDBL_MANT_DIG).
dígitos 10	int	Es un número de dígitos (en base decimal), que se pueden representar sin cambios. Equivalente a FLT_DIG, DBL_DIG o LDBL_DIG para tipos flotantes.
max_digits10	int	Es un número de dígitos (en base decimal), necesario para garantizar que los valores que difieren siempre se diferencian.
está firmado	bool	true si el tipo está firmado.
is_integer	bool	true si el tipo es entero.
is_exact	bool	true si el tipo usa representaciones exactas.
base	int	Es para tipos enteros: base de la representación. Para tipos flotantes: base del exponente de la representación (equivalente a FLT_RADIX).
épsilon ()	T	Es una máquina épsilon (la diferencia entre 1 y el menor valor mayor que 1 que es representable). Equivalente a FLT_EPSILON, DBL_EPSILON o LDBL_EPSILON para tipos flotantes.
round_error ()	T	Mide el error máximo de redondeo.
min_exponent	int	Es un valor entero negativo mínimo tal que radix elevado a (min_exponent-1)genera un número de punto flotante normalizado. Equivalente a FLT_MIN_EXP, DBL_MIN_EXP o LDBL_MIN_EXP para tipos flotantes.
min_exponent10	int	Es un valor entero negativo mínimo tal que 10 elevado a esa potencia genera un número de punto flotante normalizado. Equivalente a FLT_MIN_10_EXP, DBL_MIN_10_EXP o LDBL_MIN_10_EXP para tipos flotantes.
max_exponent	int	Es un valor entero máximo tal que la raíz elevada a (max_exponent-1)genera un número de punto flotante finito representable. Equivalente a FLT_MAX_EXP, DBL_MAX_EXP o LDBL_MAX_EXP para tipos flotantes.
max_exponent10	int	Es un valor entero máximo tal que 10 elevado a esa potencia genera un número de coma flotante finito normalizado. Equivalente a FLT_MAX_10_EXP, DBL_MAX_10_EXP o LDBL_MAX_10_EXP para tipos flotantes.
has_infinity	bool	true si el tipo tiene una representación de infinito positivo.
has_quiet_NaN	bool	true si el tipo tiene una representación de un "No-Número" silencioso (sin señalización).
has_signaling_NaN	bool	true si el tipo tiene una representación de una señalización "No es un número".
has_denorm	float_denorm_style	Es un valor desnormalizado (representaciones con un número variable de bits de exponente). Un tipo puede tener cualquiera de los siguientes valores de enumeración: denorm_absent, si no permite valores desnormalizados. denorm_present, si permite valores desnormalizados. denorm_indeterminate, si es indeterminado en tiempo de compilación.
has_denorm_loss	bool	truesi se detecta una pérdida de precisión como una pérdida de desnormalización, en lugar de un resultado inexacto.
infinito()	T	Representa un infinito positivo , si está disponible.
quiet_NaN ()	T	Representa un "No-Número" silencioso (sin señalización) , si está disponible.
señalización_NaN ()	T	Representa la señalización "No es un número" , si está disponible.
denorm_min ()	T	Valor mínimo desnormalizado positivo. Es para tipos que no permiten valores desnormalizados: igual que min().
is_iec559	bool	true si el tipo se adhiere al estándar IEC-559 / IEEE-754. Un tipo IEC-559 siempre tiene has_infinity, has_quiet_NaN y has_signaling_NaNestablecer en true; Yinfinito, quiet_NaN y señalización_NaN devuelve algún valor distinto de cero.
está ligado	bool	true si el conjunto de valores representados por el tipo es finito.
is_modulo	bool	truesi el tipo es módulo. Un tipo es módulo si es posible sumar dos números positivos y obtener un resultado que se ajuste a un tercer número menor.
trampas	bool	true si se implementa la captura para el tipo.
pequeñez_antes	bool	true si se detecta pequeñez antes de redondear.
estilo_redondo	float_round_style	Es un estilo de redondeo. Un tipo puede tener cualquiera de los siguientes valores de enumeración: round_toward_zero, si se redondea hacia cero. round_to_más cercano, si se redondea al valor representable más cercano. round_toward_infinity, si se redondea hacia el infinito. round_toward_neg_infinity, si se redondea hacia el infinito negativo. round_indeterminate, si el estilo de redondeo es indeterminable en tiempo de compilación.

Para todos los tipos anteriores que no son tipos aritméticos fundamentales, se utiliza la definición de plantilla predeterminada:

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