16 Language support library [language.support]

16.3 Implementation properties [support.limits]

16.3.1 General [support.limits.general]

1
#
The headers <limits>, <climits>, and <cfloat> supply characteristics of implementation-dependent arithmetic types ([basic.fundamental]).
2
#
The header <version> supplies implementation-dependent information about the C++ standard library (e.g., version number and release date).
3
#
The macros in Table 35 are defined after inclusion of the header <version> or one of the corresponding headers specified in the table.
[ Note
:
Future versions of this International Standard might replace the values of these macros with greater values.
— end note
 ]
Table 35 — Standard library feature-test macros
Macro name
Value
Header(s)
__cpp_­lib_­addressof_­constexpr
201603L
<memory>
__cpp_­lib_­allocator_­traits_­is_­always_­equal
201411L
<memory> <scoped_­allocator> <string> <deque> <forward_­list> <list> <vector> <map> <set> <unordered_­map> <unordered_­set>
__cpp_­lib_­any
201606L
<any>
__cpp_­lib_­apply
201603L
<tuple>
__cpp_­lib_­array_­constexpr
201603L
<iterator> <array>
__cpp_­lib_­as_­const
201510L
<utility>
__cpp_­lib_­atomic_­is_­always_­lock_­free
201603L
<atomic>
__cpp_­lib_­atomic_­ref
201806L
<atomic>
__cpp_­lib_­bit_­cast
201806L
<bit>
__cpp_­lib_­bool_­constant
201505L
<type_­traits>
__cpp_­lib_­boyer_­moore_­searcher
201603L
<functional>
__cpp_­lib_­byte
201603L
<cstddef>
__cpp_­lib_­chrono
201611L
<chrono>
__cpp_­lib_­clamp
201603L
<algorithm>
__cpp_­lib_­complex_­udls
201309L
<complex>
__cpp_­lib_­concepts
201806L
<concepts>
__cpp_­lib_­constexpr_­swap_­algorithms
201806L
<algorithm>
__cpp_­lib_­enable_­shared_­from_­this
201603L
<memory>
__cpp_­lib_­exchange_­function
201304L
<utility>
__cpp_­lib_­execution
201603L
<execution>
__cpp_­lib_­filesystem
201703L
<filesystem>
__cpp_­lib_­gcd_­lcm
201606L
<numeric>
__cpp_­lib_­generic_­associative_­lookup
201304L
<map> <set>
__cpp_­lib_­hardware_­interference_­size
201703L
<new>
__cpp_­lib_­has_­unique_­object_­representations
201606L
<type_­traits>
__cpp_­lib_­hypot
201603L
<cmath>
__cpp_­lib_­incomplete_­container_­elements
201505L
<forward_­list> <list> <vector>
__cpp_­lib_­integer_­sequence
201304L
<utility>
__cpp_­lib_­integral_­constant_­callable
201304L
<type_­traits>
__cpp_­lib_­invoke
201411L
<functional>
__cpp_­lib_­is_­aggregate
201703L
<type_­traits>
__cpp_­lib_­is_­final
201402L
<type_­traits>
__cpp_­lib_­is_­invocable
201703L
<type_­traits>
__cpp_­lib_­is_­null_­pointer
201309L
<type_­traits>
__cpp_­lib_­is_­swappable
201603L
<type_­traits>
__cpp_­lib_­launder
201606L
<new>
__cpp_­lib_­list_­remove_­return_­type
201806L
<forward_­list> <list>
__cpp_­lib_­logical_­traits
201510L
<type_­traits>
__cpp_­lib_­make_­from_­tuple
201606L
<tuple>
__cpp_­lib_­make_­reverse_­iterator
201402L
<iterator>
__cpp_­lib_­make_­unique
201304L
<memory>
__cpp_­lib_­map_­try_­emplace
201411L
<map>
__cpp_­lib_­math_­special_­functions
201603L
<cmath>
__cpp_­lib_­memory_­resource
201603L
<memory_­resource>
__cpp_­lib_­node_­extract
201606L
<map> <set> <unordered_­map> <unordered_­set>
__cpp_­lib_­nonmember_­container_­access
201411L
<iterator> <array> <deque> <forward_­list> <list> <map> <regex> <set> <string> <unordered_­map> <unordered_­set> <vector>
__cpp_­lib_­not_­fn
201603L
<functional>
__cpp_­lib_­null_­iterators
201304L
<iterator>
__cpp_­lib_­optional
201606L
<optional>
__cpp_­lib_­parallel_­algorithm
201603L
<algorithm> <numeric>
__cpp_­lib_­quoted_­string_­io
201304L
<iomanip>
__cpp_­lib_­raw_­memory_­algorithms
201606L
<memory>
__cpp_­lib_­result_­of_­sfinae
201210L
<functional> <type_­traits>
__cpp_­lib_­robust_­nonmodifying_­seq_­ops
201304L
<algorithm>
__cpp_­lib_­sample
201603L
<algorithm>
__cpp_­lib_­scoped_­lock
201703L
<mutex>
__cpp_­lib_­shared_­mutex
201505L
<shared_­mutex>
__cpp_­lib_­shared_­ptr_­arrays
201611L
<memory>
__cpp_­lib_­shared_­ptr_­weak_­type
201606L
<memory>
__cpp_­lib_­shared_­timed_­mutex
201402L
<shared_­mutex>
__cpp_­lib_­string_­udls
201304L
<string>
__cpp_­lib_­string_­view
201606L
<string> <string_­view>
__cpp_­lib_­to_­chars
201611L
<utility>
__cpp_­lib_­transformation_­trait_­aliases
201304L
<type_­traits>
__cpp_­lib_­transparent_­operators
201510L
<memory> <functional>
__cpp_­lib_­tuple_­element_­t
201402L
<tuple>
__cpp_­lib_­tuples_­by_­type
201304L
<utility> <tuple>
__cpp_­lib_­type_­trait_­variable_­templates
201510L
<type_­traits>
__cpp_­lib_­uncaught_­exceptions
201411L
<exception>
__cpp_­lib_­unordered_­map_­try_­emplace
201411L
<unordered_­map>
__cpp_­lib_­variant
201606L
<variant>
__cpp_­lib_­void_­t
201411L
<type_­traits>

16.3.2 Header <limits> synopsis [limits.syn]

namespace std {
  // [fp.style], floating-point type properties
  enum float_round_style;
  enum float_denorm_style;

  // [numeric.limits], class template numeric_­limits
  template<class T> class numeric_limits;

  template<> class numeric_limits<bool>;

  template<> class numeric_limits<char>;
  template<> class numeric_limits<signed char>;
  template<> class numeric_limits<unsigned char>;
  template<> class numeric_limits<char16_t>;
  template<> class numeric_limits<char32_t>;
  template<> class numeric_limits<wchar_t>;

  template<> class numeric_limits<short>;
  template<> class numeric_limits<int>;
  template<> class numeric_limits<long>;
  template<> class numeric_limits<long long>;
  template<> class numeric_limits<unsigned short>;
  template<> class numeric_limits<unsigned int>;
  template<> class numeric_limits<unsigned long>;
  template<> class numeric_limits<unsigned long long>;

  template<> class numeric_limits<float>;
  template<> class numeric_limits<double>;
  template<> class numeric_limits<long double>;
}

16.3.3 Floating-point type properties [fp.style]

16.3.3.1 Type float_­round_­style [round.style]

namespace std {
  enum float_round_style {
    round_indeterminate       = -1,
    round_toward_zero         =  0,
    round_to_nearest          =  1,
    round_toward_infinity     =  2,
    round_toward_neg_infinity =  3
  };
}
1
#
The rounding mode for floating-point arithmetic is characterized by the values:
  • (1.1)
    round_­indeterminate if the rounding style is indeterminable
  • (1.2)
    round_­toward_­zero if the rounding style is toward zero
  • (1.3)
    round_­to_­nearest if the rounding style is to the nearest representable value
  • (1.4)
    round_­toward_­infinity if the rounding style is toward infinity
  • (1.5)
    round_­toward_­neg_­infinity if the rounding style is toward negative infinity

16.3.3.2 Type float_­denorm_­style [denorm.style]

namespace std {
  enum float_denorm_style {
    denorm_indeterminate = -1,
    denorm_absent = 0,
    denorm_present = 1
  };
}
1
#
The presence or absence of subnormal numbers (variable number of exponent bits) is characterized by the values:
  • (1.1)
    denorm_­indeterminate if it cannot be determined whether or not the type allows subnormal values
  • (1.2)
    denorm_­absent if the type does not allow subnormal values
  • (1.3)
    denorm_­present if the type does allow subnormal values

16.3.4 Class template numeric_­limits [numeric.limits]

1
#
The numeric_­limits class template provides a C++ program with information about various properties of the implementation's representation of the arithmetic types.
namespace std {
  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 int  max_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;
    static constexpr float_round_style round_style = round_toward_zero;
  };

  template<class T> class numeric_limits<const T>;
  template<class T> class numeric_limits<volatile T>;
  template<class T> class numeric_limits<const volatile T>;
}
2
#
For all members declared static constexpr in the numeric_­limits template, specializations shall define these values in such a way that they are usable as constant expressions.
3
#
The default numeric_­limits<T> template shall have all members, but with 0 or false values.
4
#
Specializations shall be provided for each arithmetic type, both floating-point and integer, including bool.
The member is_­specialized shall be true for all such specializations of numeric_­limits.
5
#
The value of each member of a specialization of numeric_­limits on a cv-qualified type cv T shall be equal to the value of the corresponding member of the specialization on the unqualified type T.
6
#
Non-arithmetic standard types, such as complex<T>, shall not have specializations.

16.3.4.1 numeric_­limits members [numeric.limits.members]

1
#
Each member function defined in this subclause is signal-safe.
🔗
static constexpr T min() noexcept;
2
#
Minimum finite value.190
3
#
For floating-point types with subnormal numbers, returns the minimum positive normalized value.
4
#
Meaningful for all specializations in which is_­bounded != false, or is_­bounded == false && is_­signed == false.
🔗
static constexpr T max() noexcept;
5
#
Maximum finite value.191
6
#
Meaningful for all specializations in which is_­bounded != false.
🔗
static constexpr T lowest() noexcept;
7
#
A finite value x such that there is no other finite value y where y < x.192
8
#
Meaningful for all specializations in which is_­bounded != false.
🔗
static constexpr int digits;
9
#
Number of radix digits that can be represented without change.
10
#
For integer types, the number of non-sign bits in the representation.
11
#
For floating-point types, the number of radix digits in the mantissa.193
🔗
static constexpr int digits10;
12
#
Number of base 10 digits that can be represented without change.194
13
#
Meaningful for all specializations in which is_­bounded != false.
🔗
static constexpr int max_digits10;
14
#
Number of base 10 digits required to ensure that values which differ are always differentiated.
15
#
Meaningful for all floating-point types.
🔗
static constexpr bool is_signed;
16
#
true if the type is signed.
17
#
Meaningful for all specializations.
🔗
static constexpr bool is_integer;
18
#
true if the type is integer.
19
#
Meaningful for all specializations.
🔗
static constexpr bool is_exact;
20
#
true if the type uses an exact representation.
All integer types are exact, but not all exact types are integer.
For example, rational and fixed-exponent representations are exact but not integer.
21
#
Meaningful for all specializations.
🔗
static constexpr int radix;
22
#
For floating-point types, specifies the base or radix of the exponent representation (often 2).195
23
#
For integer types, specifies the base of the representation.196
24
#
Meaningful for all specializations.
🔗
static constexpr T epsilon() noexcept;
25
#
Machine epsilon: the difference between 1 and the least value greater than 1 that is representable.197
26
#
Meaningful for all floating-point types.
🔗
static constexpr T round_error() noexcept;
27
#
Measure of the maximum rounding error.198
🔗
static constexpr int min_exponent;
28
#
Minimum negative integer such that radix raised to the power of one less than that integer is a normalized floating-point number.199
29
#
Meaningful for all floating-point types.
🔗
static constexpr int min_exponent10;
30
#
Minimum negative integer such that 10 raised to that power is in the range of normalized floating-point numbers.200
31
#
Meaningful for all floating-point types.
🔗
static constexpr int max_exponent;
32
#
Maximum positive integer such that radix raised to the power one less than that integer is a representable finite floating-point number.201
33
#
Meaningful for all floating-point types.
🔗
static constexpr int max_exponent10;
34
#
Maximum positive integer such that 10 raised to that power is in the range of representable finite floating-point numbers.202
35
#
Meaningful for all floating-point types.
🔗
static constexpr bool has_infinity;
36
#
true if the type has a representation for positive infinity.
37
#
Meaningful for all floating-point types.
38
#
Shall be true for all specializations in which is_­iec559 != false.
🔗
static constexpr bool has_quiet_NaN;
39
#
true if the type has a representation for a quiet (non-signaling) “Not a Number”.203
40
#
Meaningful for all floating-point types.
41
#
Shall be true for all specializations in which is_­iec559 != false.
🔗
static constexpr bool has_signaling_NaN;
42
#
true if the type has a representation for a signaling “Not a Number”.204
43
#
Meaningful for all floating-point types.
44
#
Shall be true for all specializations in which is_­iec559 != false.
🔗
static constexpr float_denorm_style has_denorm;
45
#
denorm_­present if the type allows subnormal values (variable number of exponent bits)205, denorm_­absent if the type does not allow subnormal values, and denorm_­indeterminate if it is indeterminate at compile time whether the type allows subnormal values.
46
#
Meaningful for all floating-point types.
🔗
static constexpr bool has_denorm_loss;
47
#
true if loss of accuracy is detected as a denormalization loss, rather than as an inexact result.206
🔗
static constexpr T infinity() noexcept;
48
#
Representation of positive infinity, if available.207
49
#
Meaningful for all specializations for which has_­infinity != false.
Required in specializations for which is_­iec559 != false.
🔗
static constexpr T quiet_NaN() noexcept;
50
#
Representation of a quiet “Not a Number”, if available.208
51
#
Meaningful for all specializations for which has_­quiet_­NaN != false.
Required in specializations for which is_­iec559 != false.
🔗
static constexpr T signaling_NaN() noexcept;
52
#
Representation of a signaling “Not a Number”, if available.209
53
#
Meaningful for all specializations for which has_­signaling_­NaN != false.
Required in specializations for which is_­iec559 != false.
🔗
static constexpr T denorm_min() noexcept;
54
#
Minimum positive subnormal value.210
55
#
Meaningful for all floating-point types.
56
#
In specializations for which has_­denorm == false, returns the minimum positive normalized value.
🔗
static constexpr bool is_iec559;
57
#
true if and only if the type adheres to ISO/IEC/IEEE 60559.211
58
#
Meaningful for all floating-point types.
🔗
static constexpr bool is_bounded;
59
#
true if the set of values representable by the type is finite.212
[ Note
:
All fundamental types ([basic.fundamental]) are bounded.
This member would be false for arbitrary precision types.
— end note
 ]
60
#
Meaningful for all specializations.
🔗
static constexpr bool is_modulo;
61
#
true if the type is modulo.213
A type is modulo if, for any operation involving +, -, or * on values of that type whose result would fall outside the range [min(), max()], the value returned differs from the true value by an integer multiple of max() - min() + 1.
62
#
[ Example
:
is_­modulo is false for signed integer types ([basic.fundamental]) unless an implementation, as an extension to this document, defines signed integer overflow to wrap.
— end example
 ]
63
#
Meaningful for all specializations.
🔗
static constexpr bool traps;
64
#
true if, at program startup, there exists a value of the type that would cause an arithmetic operation using that value to trap.214
65
#
Meaningful for all specializations.
🔗
static constexpr bool tinyness_before;
66
#
true if tinyness is detected before rounding.215
67
#
Meaningful for all floating-point types.
🔗
static constexpr float_round_style round_style;
68
#
The rounding style for the type.216
69
#
Meaningful for all floating-point types.
Specializations for integer types shall return round_­toward_­zero.
190)
Equivalent to CHAR_­MIN, SHRT_­MIN, FLT_­MIN, DBL_­MIN, etc.
191)
Equivalent to CHAR_­MAX, SHRT_­MAX, FLT_­MAX, DBL_­MAX, etc.
192)
lowest() is necessary because not all floating-point representations have a smallest (most negative) value that is the negative of the largest (most positive) finite value.
193)
Equivalent to FLT_­MANT_­DIG, DBL_­MANT_­DIG, LDBL_­MANT_­DIG.
194)
Equivalent to FLT_­DIG, DBL_­DIG, LDBL_­DIG.
195)
Equivalent to FLT_­RADIX.
196)
Distinguishes types with bases other than 2 (e.g. BCD).
197)
Equivalent to FLT_­EPSILON, DBL_­EPSILON, LDBL_­EPSILON.
198)
Rounding error is described in LIA-1 Section 5.2.4 and Annex C Rationale Section C.5.2.4 — Rounding and rounding constants.
199)
Equivalent to FLT_­MIN_­EXP, DBL_­MIN_­EXP, LDBL_­MIN_­EXP.
200)
Equivalent to FLT_­MIN_­10_­EXP, DBL_­MIN_­10_­EXP, LDBL_­MIN_­10_­EXP.
201)
Equivalent to FLT_­MAX_­EXP, DBL_­MAX_­EXP, LDBL_­MAX_­EXP.
202)
Equivalent to FLT_­MAX_­10_­EXP, DBL_­MAX_­10_­EXP, LDBL_­MAX_­10_­EXP.
203)
Required by LIA-1.
204)
Required by LIA-1.
205)
Required by LIA-1.
206)
See ISO/IEC/IEEE 60559.
207)
Required by LIA-1.
208)
Required by LIA-1.
209)
Required by LIA-1.
210)
Required by LIA-1.
211)
ISO/IEC/IEEE 60559:2011 is the same as IEEE 754-2008.
212)
Required by LIA-1.
213)
Required by LIA-1.
214)
Required by LIA-1.
215)
Refer to ISO/IEC/IEEE 60559.
Required by LIA-1.
216)
Equivalent to FLT_­ROUNDS.
Required by LIA-1.

16.3.4.2 numeric_­limits specializations [numeric.special]

1
#
All members shall be provided for all specializations.
However, many values are only required to be meaningful under certain conditions (for example, epsilon() is only meaningful if is_­integer is false).
Any value that is not “meaningful” shall be set to 0 or false.
2
#
[ Example
: 
namespace std {
  template<> class numeric_limits<float> {
  public:
    static constexpr bool is_specialized = true;

    static constexpr float min() noexcept { return 1.17549435E-38F; }
    static constexpr float max() noexcept { return 3.40282347E+38F; }
    static constexpr float lowest() noexcept { return -3.40282347E+38F; }

    static constexpr int digits   = 24;
    static constexpr int digits10 =  6;
    static constexpr int max_digits10 =  9;

    static constexpr bool is_signed  = true;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact   = false;

    static constexpr int radix = 2;
    static constexpr float epsilon() noexcept     { return 1.19209290E-07F; }
    static constexpr float round_error() noexcept { return 0.5F; }

    static constexpr int min_exponent   = -125;
    static constexpr int min_exponent10 = - 37;
    static constexpr int max_exponent   = +128;
    static constexpr int max_exponent10 = + 38;

    static constexpr bool has_infinity             = true;
    static constexpr bool has_quiet_NaN            = true;
    static constexpr bool has_signaling_NaN        = true;
    static constexpr float_denorm_style has_denorm = denorm_absent;
    static constexpr bool has_denorm_loss          = false;

    static constexpr float infinity()      noexcept { return value; }
    static constexpr float quiet_NaN()     noexcept { return value; }
    static constexpr float signaling_NaN() noexcept { return value; }
    static constexpr float denorm_min()    noexcept { return min(); }

    static constexpr bool is_iec559  = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo  = false;
    static constexpr bool traps      = true;
    static constexpr bool tinyness_before = true;

    static constexpr float_round_style round_style = round_to_nearest;
  };
}
— end example
 ]
3
#
The specialization for bool shall be provided as follows: 
namespace std {
   template<> class numeric_limits<bool> {
   public:
     static constexpr bool is_specialized = true;
     static constexpr bool min() noexcept { return false; }
     static constexpr bool max() noexcept { return true; }
     static constexpr bool lowest() noexcept { return false; }

     static constexpr int  digits = 1;
     static constexpr int  digits10 = 0;
     static constexpr int  max_digits10 = 0;

     static constexpr bool is_signed = false;
     static constexpr bool is_integer = true;
     static constexpr bool is_exact = true;
     static constexpr int  radix = 2;
     static constexpr bool epsilon() noexcept { return 0; }
     static constexpr bool round_error() noexcept { return 0; }

     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 bool infinity() noexcept { return 0; }
     static constexpr bool quiet_NaN() noexcept { return 0; }
     static constexpr bool signaling_NaN() noexcept { return 0; }
     static constexpr bool denorm_min() noexcept { return 0; }

     static constexpr bool is_iec559 = false;
     static constexpr bool is_bounded = true;
     static constexpr bool is_modulo = false;

     static constexpr bool traps = false;
     static constexpr bool tinyness_before = false;
     static constexpr float_round_style round_style = round_toward_zero;
   };
}

16.3.5 Header <climits> synopsis [climits.syn]

#define CHAR_BIT see below
#define SCHAR_MIN see below
#define SCHAR_MAX see below
#define UCHAR_MAX see below
#define CHAR_MIN see below
#define CHAR_MAX see below
#define MB_LEN_MAX see below
#define SHRT_MIN see below
#define SHRT_MAX see below
#define USHRT_MAX see below
#define INT_MIN see below
#define INT_MAX see below
#define UINT_MAX see below
#define LONG_MIN see below
#define LONG_MAX see below
#define ULONG_MAX see below
#define LLONG_MIN see below
#define LLONG_MAX see below
#define ULLONG_MAX see below
1
#
The header <climits> defines all macros the same as the C standard library header <limits.h>.
[ Note
:
The types of the constants defined by macros in <climits> are not required to match the types to which the macros refer.
— end note
 ]
See also: ISO C 5.2.4.2.1

16.3.6 Header <cfloat> synopsis [cfloat.syn]

#define FLT_ROUNDS see below
#define FLT_EVAL_METHOD see below
#define FLT_HAS_SUBNORM see below
#define DBL_HAS_SUBNORM see below
#define LDBL_HAS_SUBNORM see below
#define FLT_RADIX see below
#define FLT_MANT_DIG see below
#define DBL_MANT_DIG see below
#define LDBL_MANT_DIG see below
#define FLT_DECIMAL_DIG see below
#define DBL_DECIMAL_DIG see below
#define LDBL_DECIMAL_DIG see below
#define DECIMAL_DIG see below
#define FLT_DIG see below
#define DBL_DIG see below
#define LDBL_DIG see below
#define FLT_MIN_EXP see below
#define DBL_MIN_EXP see below
#define LDBL_MIN_EXP see below
#define FLT_MIN_10_EXP see below
#define DBL_MIN_10_EXP see below
#define LDBL_MIN_10_EXP see below
#define FLT_MAX_EXP see below
#define DBL_MAX_EXP see below
#define LDBL_MAX_EXP see below
#define FLT_MAX_10_EXP see below
#define DBL_MAX_10_EXP see below
#define LDBL_MAX_10_EXP see below
#define FLT_MAX see below
#define DBL_MAX see below
#define LDBL_MAX see below
#define FLT_EPSILON see below
#define DBL_EPSILON see below
#define LDBL_EPSILON see below
#define FLT_MIN see below
#define DBL_MIN see below
#define LDBL_MIN see below
#define FLT_TRUE_MIN see below
#define DBL_TRUE_MIN see below
#define LDBL_TRUE_MIN see below
1
#
The header <cfloat> defines all macros the same as the C standard library header <float.h>.
See also: ISO C 5.2.4.2.2