Cpp Standard Library 简明教程

C++ Library - <limits>

Introduction

它是一个数值限制类型，它提供有关特定平台上算术类型（整数或浮点数）的属性的信息，该平台是该库进行编译的。

It is a Numeric limits type and it provides information about the properties of arithmetic types (either integral or floating-point) in the specific platform for which the library compiles.

Declaration

以下是 std::numeric_limits 的声明。

Following is the declaration for std::numeric_limits.

template <class T> numeric_limits;

C++11

template <class T> numeric_limits;

Parameters

T − 它是一个类类型。

T − It is a type of class.

Example

在 std::numeric_limits 以下示例中。

In below example for 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';
}

示例输出如下所示 −

The sample output should be like this −

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

Template instantiations

C++98 的基本算术类型应如下所示：

The fundamental arithmetic types of C++98 should be like this −

fundamental arithmetic types

integral types

bool

char

wchar_t

signed char

short int

int

long int

unsigned char

unsigned short int

unsigned int

unsigned long int

floating point types

float

double

long double

C++11 的基本算术类型应如下所示：

The fundamental arithmetic types of C++11 should be like this −

fundamental arithmetic types

integral types

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

floating point types

float

double

long double

Members

member

type

property

is_specialized

bool

It is true for all (i.e., those for which numeric_limits is specialized). and false for all other types.

min()

T

It is a minimum finite value. For floating types with denormalization (variable number of exponent bits): minimum positive normalized value. Equivalent to CHAR_MIN, SCHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, BL_MIN, LDBL_MIN or 0, depending on type.

max()

T

It is a maximum finite value. Equivalent to 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 or LDBL_MAX, depending on type.

lowest()

T

It is a minimum finite value. (since C++11) For integral types: the same as min(). For floating-point types: implementation-dependent; generally, the negative of max().

digits

int

It is for integer types: number of non-sign bits (radix base digits) in the representation. For floating types: number of digits (in radix base) in the mantissa (equivalent to FLT_MANT_DIG, DBL_MANT_DIG or LDBL_MANT_DIG).

digits10

int

It is a number of digits (in decimal base), that can be represented without change. Equivalent to FLT_DIG, DBL_DIG or LDBL_DIG for floating types.

max_digits10

int

It is a number of digits (in decimal base), that required to ensure that values that differ are always differentiated.

is_signed

bool

true if type is signed.

is_integer

bool

true if type is integer.

is_exact

bool

true if type uses exact representations.

radix

int

It is for integer types: base of the representation. For floating types: base of the exponent of the representation (equivalent to FLT_RADIX).

epsilon()

T

It is a machine epsilon (the difference between 1 and the least value greater than 1 that is representable). Equivalent to FLT_EPSILON, DBL_EPSILON or LDBL_EPSILON for floating types.

round_error()

T

It measures of the maximum rounding error.

min_exponent

int

It is a minimum negative integer value such that radix raised to (min_exponent-1) generates a normalized floating-point number. Equivalent to FLT_MIN_EXP, DBL_MIN_EXP or LDBL_MIN_EXP for floating types.

min_exponent10

int

It is a minimum negative integer value such that 10 raised to that power generates a normalized floating-point number. Equivalent to FLT_MIN_10_EXP, DBL_MIN_10_EXP or LDBL_MIN_10_EXP for floating types.

max_exponent

int

It is a maximum integer value such that radix raised to (max_exponent-1) generates a representable finite floating-point number. Equivalent to FLT_MAX_EXP, DBL_MAX_EXP or LDBL_MAX_EXP for floating types.

max_exponent10

int

It is a maximum integer value such that 10 raised to that power generates a normalized finite floating-point number. Equivalent to FLT_MAX_10_EXP, DBL_MAX_10_EXP or LDBL_MAX_10_EXP for floating types.

has_infinity

bool

true if the type has a representation for positive infinity.

has_quiet_NaN

bool

true if the type has a representation for a quiet (non-signaling) "Not-a-Number".

has_signaling_NaN

bool

true if the type has a representation for a signaling "Not-a-Number".

has_denorm

float_denorm_style

It is a denormalized values (representations with a variable number of exponent bits). A type may have any of the following enum values − denorm_absent, if it does not allow denormalized values. denorm_present, if it allows denormalized values. denorm_indeterminate, if indeterminate at compile time.

has_denorm_loss

bool

true if a loss of accuracy is detected as a denormalization loss, rather than an inexact result.

infinity()

T

It represents of positive infinity, if available.

quiet_NaN()

T

It represents of quiet (non-signaling) "Not-a-Number", if available.

signaling_NaN()

T

It represents of signaling "Not-a-Number", if available.

denorm_min()

T

Minimum positive denormalized value. It is for types not allowing denormalized values: same as min().

is_iec559

bool

true if the type adheres to IEC-559 / IEEE-754 standard. An IEC-559 type always has has_infinity, has_quiet_NaN and has_signaling_NaN set to true; And infinity, quiet_NaN and signaling_NaN return some non-zero value.

is_bounded

bool

true if the set of values represented by the type is finite.

is_modulo

bool

true if the type is modulo. A type is modulo if it is possible to add two positive numbers and have a result that wraps around to a third number that is less.

traps

bool

true if trapping is implemented for the type.

tinyness_before

bool

true if tinyness is detected before rounding.

round_style

float_round_style

It is a rounding style. A type may have any of the following enum values − round_toward_zero, if it rounds toward zero. round_to_nearest, if it rounds to the nearest representable value. round_toward_infinity, if it rounds toward infinity. round_toward_neg_infinity, if it rounds toward negative infinity. round_indeterminate, if the rounding style is indeterminable at compile time.

对于不是基本算术类型的上述所有类型，使用默认模板定义 −

For all above types that are not fundamental arithmetic types, the default template definition is used −

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