The <limits> header declares the numeric_limits class template and related types and specializations that define the limits and characteristics of the fundamental arithmetic types (such as the largest possible int). It is the C++ equivalent of the C headers <cfloat> and <climits> (and the wchar_t limits in <cwchar>).
The <limits> header has a number of advantages over the <cfloat> and <climits> declarations. In particular, by using a template, you can write your own templatebased classes that depend on the characteristics of a template parameter; this is not possible with the macrobased C headers.
float_denorm_style type  Represents existence of denormalized, floatingpoint values 
enum float_denorm_style {
denorm_indeterminate = 1;
denorm_absent = 0;
denorm_present = 1;
};

The float_denorm_style type is an enumerated type that represents whether denormalized floatingpoint values are supported.
float_round_style type  Represents the floatingpoint rounding style 
enum float_round_style {
round_indeterminate = 1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};

The float_round_style type is an enumerated type that represents how floatingpoint numbers are rounded.
numeric_limits class template  Represents the limits and characteristics of an arithmetic type 
template<typename 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; }; 
The numeric_limits class template represents the limits and characteristics of an arithmetic type. The data members that are shown as static const are constants that you can use in other integral constant expressions.
The default is for all members to be 0 or false. The header has specializations for all fundamental types, and only for the fundamental types. Every specialization in the standard library defines every member, even if the member does not pertain to the type (e.g., floatingpoint characteristics of an integral type). Meaningless members are defined as 0 or false.
You can specialize numeric_limits for your own types. For example, suppose you write a class, bigint, to represent integers of arbitrary size. You can define your specialization to show that the type is unbounded, signed, integral, etc. You should follow the convention of the standard library, namely, by defining all members, even if they do not apply to your type. Be sure to define is_specialized as true.
Use numeric_limits to query the properties or traits of a numeric type. For example, suppose you are writing a data analysis program. Among the data are points you want to ignore, but you need to keep their places in the data array. You decide to insert a special marker value. Ideally, the marker value (such as infinity) cannot possibly appear in the actual data stream. If the floatingpoint type that you are using does not support infinity, you can use the maximum finite value. Example 1323 lists the no_data function, which returns the value used for the nodata marker.
// Define a template that will differentiate types that have a specialized
// numeric_limits and an explicit value for infinity.
template<typename T, bool is_specialized, bool has_infinity>
struct max_or_infinity
{};
// Specialize the template to obtain the value of infinity.
template<typename T>
struct max_or_infinity<T, true, true>
{
static T value( )
{ return std::numeric_limits<T>::infinity( ); }
};
// Specialize the template if infinity is not supported.
template<typename T>
struct max_or_infinity<T, true, false>
{
static T value( ) { return std::numeric_limits<T>::max( ); }
};
// Note that a type without a numeric_limits specialization does not have a
// max_or_infinity specialization, so the no_data function would result in
// compiletime errors when applied to such a type.
//
// The no_data function returns a value that can be used to mark points that do
// not have valid data.
template<typename T>
T no_data( )
{
return max_or_infinity<T,
std::numeric_limits<T>::is_specialized,
std::numeric_limits<T>::has_infinity>::value( );
}
The C++ standard mandates that all integers are binary and use two's complement, ones' complement, or signed magnitude representation. The representation of floatingpoint numbers is not specified. The numeric_limits template assumes that a number is represented as a sign, a significand (sometimes called the mantissa), a base, and an exponent:
In everyday arithmetic, we are used to working with a base of 10. (The base is also called the radix.) The most common bases for computer arithmetic, however, are 16 and 2. Many modern workstations use the IEC 60559 (IEEE 754) standard for floatingpoint arithmetic, which uses a base of 2.
The significand is a string of digits in the given base. There is an implied radix point at the start of the significand, so the value of the significand is always less than one. (A radix point is the generalization of a decimal point for any radix.)
A finite floatingpoint value is normalized if the first digit of its significand is nonzero, or if the entire value is 0. The term denormalized means a finite value is not normalized.
The precision of a floatingpoint type is the maximum number of places in the significand. The range of a floatingpoint type depends primarily on the minimum and maximum values for the exponent.
The following are descriptions of the members of numeric_limits:
Returns the smallest positive, denormalized floatingpoint value. If has_denorm is false, it returns the smallest positive normalized value. For nonfloatingpoint types, it returns 0.
The number of radix digits that can be represented. For integer types, it is the number of nonsign bits; for floatingpoint types, it is the number of places in the significand.
The number of decimal digits that can be represented. If is_bounded is false, digits10 is 0.
Returns the difference between 1.0 and the smallest representable value greater than 1.0. For integral types, epsilon returns 0.
Indicates the denormalized, floatingpoint style. It is denorm_indeterminate if the style cannot be determined at compile time. It is meaningful for all floatingpoint types.
Indicates whether the loss of accuracy in a floatingpoint computation is a denormalization loss rather than an inexact result.
Indicates whether the floatingpoint type can represent positive infinity. In particular, has_infinity is true when is_iec559 is true.
Indicates whether the floatingpoint type can represent a quiet (nonsignaling) NaN (notanumber). In particular, this is true when is_iec559 is true.
Indicates whether the floating point type can represent a signaling NaN. In particular, this is true when is_iec559 is true.
Returns the value of positive infinity if has_infinity is true.
Indicates whether the type represents a finite set of values. This is true for all fundamental types.
Indicates whether the type represents values exactly. It is true for all integral types and false for the fundamental floatingpoint types.
Indicates whether the type follows the IEC 60559 (IEEE 754) standard for floatingpoint arithmetic. It is meaningful only for floatingpoint types. Among the requirements of the IEC 60559 standard are support for positive and negative infinity, and for values that are NaN.
true for all integral types.
Indicates whether the type uses modulo arithmetic. This is always true for unsigned integral types and often true for signed integral types. It is false for typical floatingpoint types.
Indicates whether the type is signed, that is, supports positive and negative values.
Indicates whether numeric_limits is specialized for the type. It is false by default, so you can detect whether numeric_limits<> has been specialized for a particular type, and therefore determine whether a false or 0 value is meaningful.
Returns the maximum finite value when is_bounded is true.
The largest allowable exponent for a finite floatingpoint number.
The largest allowable decimal exponent for a finite floatingpoint number.
Returns the minimum finite value. It is meaningful when is_bounded is true or when is_bounded and is_signed are both false.
The smallest allowable exponent for a floatingpoint number such that radix raised to min_exponent  1 is representable as a normalized floatingpoint number.
The smallest negative decimal exponent such that 10 raised to min_exponent10 is representable as a normalized floatingpoint number.
Returns a quiet NaN value if has_quiet_NaN is true.
The base used in the representation of a numeric value. For floatingpoint numbers, it is the base of the exponent.
Returns the maximum rounding error.
Indicates the rounding style used by the floatingpoint type. (See the float_round_style type for a definition of the possible return values.) For integral types, the return value is always round_toward_zero.
Returns a signaling NaN value if has_signaling_NaN is true.
Indicates whether a floatingpoint type tests for denormalized values before rounding.
Indicates whether arithmetic errors trap, that is, result in signals or exceptions. It is false if errors are quietly ignored.
The numeric_limits template is specialized for all the fundamental numeric types and for no other types in the C++ standard. In each case, is_specialized is true, and other members are set as appropriate. The C++ standard (by way of the C standard) defines the minimum requirements for an implementation. The requirements for integral types are given in <climits>, and for floatingpoint types in <cfloat>.
The following are the standard specializations: