17 Language support library [support]

17.3 Implementation properties [support.limits]

17.3.1 General [support.limits.general]

The headers <limits>, <climits>, and <cfloat> supply characteristics of implementation-dependent arithmetic types ([basic.fundamental]).

17.3.2 Header <version> synopsis [version.syn]

The header <version> supplies implementation-dependent information about the C++ standard library (e.g., version number and release date).
Each of the macros defined in <version> is also defined after inclusion of any member of the set of library headers indicated in the corresponding comment in this synopsis.
[Note 1:
Future revisions of C++ might replace the values of these macros with greater values.
— end note]
#define __cpp_­lib_­addressof_­constexpr 201603L // also in <memory> #define __cpp_­lib_­allocator_­traits_­is_­always_­equal 201411L // also in <memory>, <scoped_­allocator>, <string>, <deque>, <forward_­list>, <list>, <vector>, // <map>, <set>, <unordered_­map>, <unordered_­set> #define __cpp_­lib_­any 201606L // also in <any> #define __cpp_­lib_­apply 201603L // also in <tuple> #define __cpp_­lib_­array_­constexpr 201811L // also in <iterator>, <array> #define __cpp_­lib_­as_­const 201510L // also in <utility> #define __cpp_­lib_­assume_­aligned 201811L // also in <memory> #define __cpp_­lib_­atomic_­flag_­test 201907L // also in <atomic> #define __cpp_­lib_­atomic_­float 201711L // also in <atomic> #define __cpp_­lib_­atomic_­is_­always_­lock_­free 201603L // also in <atomic> #define __cpp_­lib_­atomic_­lock_­free_­type_­aliases 201907L // also in <atomic> #define __cpp_­lib_­atomic_­ref 201806L // also in <atomic> #define __cpp_­lib_­atomic_­shared_­ptr 201711L // also in <memory> #define __cpp_­lib_­atomic_­value_­initialization 201911L // also in <atomic>, <memory> #define __cpp_­lib_­atomic_­wait 201907L // also in <atomic> #define __cpp_­lib_­barrier 201907L // also in <barrier> #define __cpp_­lib_­bind_­front 201907L // also in <functional> #define __cpp_­lib_­bit_­cast 201806L // also in <bit> #define __cpp_­lib_­bitops 201907L // also in <bit> #define __cpp_­lib_­bool_­constant 201505L // also in <type_­traits> #define __cpp_­lib_­bounded_­array_­traits 201902L // also in <type_­traits> #define __cpp_­lib_­boyer_­moore_­searcher 201603L // also in <functional> #define __cpp_­lib_­byte 201603L // also in <cstddef> #define __cpp_­lib_­char8_­t 201907L // also in <atomic>, <filesystem>, <istream>, <limits>, <locale>, <ostream>, <string>, <string_­view> #define __cpp_­lib_­chrono 201907L // also in <chrono> #define __cpp_­lib_­chrono_­udls 201304L // also in <chrono> #define __cpp_­lib_­clamp 201603L // also in <algorithm> #define __cpp_­lib_­complex_­udls 201309L // also in <complex> #define __cpp_­lib_­concepts 202002L // also in <concepts> #define __cpp_­lib_­constexpr_­algorithms 201806L // also in <algorithm> #define __cpp_­lib_­constexpr_­complex 201711L // also in <complex> #define __cpp_­lib_­constexpr_­dynamic_­alloc 201907L // also in <memory> #define __cpp_­lib_­constexpr_­functional 201907L // also in <functional> #define __cpp_­lib_­constexpr_­iterator 201811L // also in <iterator> #define __cpp_­lib_­constexpr_­memory 201811L // also in <memory> #define __cpp_­lib_­constexpr_­numeric 201911L // also in <numeric> #define __cpp_­lib_­constexpr_­string 201907L // also in <string> #define __cpp_­lib_­constexpr_­string_­view 201811L // also in <string_­view> #define __cpp_­lib_­constexpr_­tuple 201811L // also in <tuple> #define __cpp_­lib_­constexpr_­utility 201811L // also in <utility> #define __cpp_­lib_­constexpr_­vector 201907L // also in <vector> #define __cpp_­lib_­coroutine 201902L // also in <coroutine> #define __cpp_­lib_­destroying_­delete 201806L // also in <new> #define __cpp_­lib_­enable_­shared_­from_­this 201603L // also in <memory> #define __cpp_­lib_­endian 201907L // also in <bit> #define __cpp_­lib_­erase_­if 202002L // also in <string>, <deque>, <forward_­list>, <list>, <vector>, <map>, <set>, <unordered_­map>, // <unordered_­set> #define __cpp_­lib_­exchange_­function 201304L // also in <utility> #define __cpp_­lib_­execution 201902L // also in <execution> #define __cpp_­lib_­filesystem 201703L // also in <filesystem> #define __cpp_­lib_­format 201907L // also in <format> #define __cpp_­lib_­gcd_­lcm 201606L // also in <numeric> #define __cpp_­lib_­generic_­associative_­lookup 201304L // also in <map>, <set> #define __cpp_­lib_­generic_­unordered_­lookup 201811L // also in <unordered_­map>, <unordered_­set> #define __cpp_­lib_­hardware_­interference_­size 201703L // also in <new> #define __cpp_­lib_­has_­unique_­object_­representations 201606L // also in <type_­traits> #define __cpp_­lib_­hypot 201603L // also in <cmath> #define __cpp_­lib_­incomplete_­container_­elements 201505L // also in <forward_­list>, <list>, <vector> #define __cpp_­lib_­int_­pow2 202002L // also in <bit> #define __cpp_­lib_­integer_­comparison_­functions 202002L // also in <utility> #define __cpp_­lib_­integer_­sequence 201304L // also in <utility> #define __cpp_­lib_­integral_­constant_­callable 201304L // also in <type_­traits> #define __cpp_­lib_­interpolate 201902L // also in <cmath>, <numeric> #define __cpp_­lib_­invoke 201411L // also in <functional> #define __cpp_­lib_­is_­aggregate 201703L // also in <type_­traits> #define __cpp_­lib_­is_­constant_­evaluated 201811L // also in <type_­traits> #define __cpp_­lib_­is_­final 201402L // also in <type_­traits> #define __cpp_­lib_­is_­invocable 201703L // also in <type_­traits> #define __cpp_­lib_­is_­layout_­compatible 201907L // also in <type_­traits> #define __cpp_­lib_­is_­nothrow_­convertible 201806L // also in <type_­traits> #define __cpp_­lib_­is_­null_­pointer 201309L // also in <type_­traits> #define __cpp_­lib_­is_­pointer_­interconvertible 201907L // also in <type_­traits> #define __cpp_­lib_­is_­swappable 201603L // also in <type_­traits> #define __cpp_­lib_­jthread 201911L // also in <stop_­token>, <thread> #define __cpp_­lib_­latch 201907L // also in <latch> #define __cpp_­lib_­launder 201606L // also in <new> #define __cpp_­lib_­list_­remove_­return_­type 201806L // also in <forward_­list>, <list> #define __cpp_­lib_­logical_­traits 201510L // also in <type_­traits> #define __cpp_­lib_­make_­from_­tuple 201606L // also in <tuple> #define __cpp_­lib_­make_­reverse_­iterator 201402L // also in <iterator> #define __cpp_­lib_­make_­unique 201304L // also in <memory> #define __cpp_­lib_­map_­try_­emplace 201411L // also in <map> #define __cpp_­lib_­math_­constants 201907L // also in <numbers> #define __cpp_­lib_­math_­special_­functions 201603L // also in <cmath> #define __cpp_­lib_­memory_­resource 201603L // also in <memory_­resource> #define __cpp_­lib_­node_­extract 201606L // also in <map>, <set>, <unordered_­map>, <unordered_­set> #define __cpp_­lib_­nonmember_­container_­access 201411L // also in <array>, <deque>, <forward_­list>, <iterator>, <list>, <map>, <regex>, <set>, <string>, // <unordered_­map>, <unordered_­set>, <vector> #define __cpp_­lib_­not_­fn 201603L // also in <functional> #define __cpp_­lib_­null_­iterators 201304L // also in <iterator> #define __cpp_­lib_­optional 201606L // also in <optional> #define __cpp_­lib_­parallel_­algorithm 201603L // also in <algorithm>, <numeric> #define __cpp_­lib_­polymorphic_­allocator 201902L // also in <memory> #define __cpp_­lib_­quoted_­string_­io 201304L // also in <iomanip> #define __cpp_­lib_­ranges 201911L // also in <algorithm>, <functional>, <iterator>, <memory>, <ranges> #define __cpp_­lib_­raw_­memory_­algorithms 201606L // also in <memory> #define __cpp_­lib_­remove_­cvref 201711L // also in <type_­traits> #define __cpp_­lib_­result_­of_­sfinae 201210L // also in <functional>, <type_­traits> #define __cpp_­lib_­robust_­nonmodifying_­seq_­ops 201304L // also in <algorithm> #define __cpp_­lib_­sample 201603L // also in <algorithm> #define __cpp_­lib_­scoped_­lock 201703L // also in <mutex> #define __cpp_­lib_­semaphore 201907L // also in <semaphore> #define __cpp_­lib_­shared_­mutex 201505L // also in <shared_­mutex> #define __cpp_­lib_­shared_­ptr_­arrays 201707L // also in <memory> #define __cpp_­lib_­shared_­ptr_­weak_­type 201606L // also in <memory> #define __cpp_­lib_­shared_­timed_­mutex 201402L // also in <shared_­mutex> #define __cpp_­lib_­shift 201806L // also in <algorithm> #define __cpp_­lib_­smart_­ptr_­for_­overwrite 202002L // also in <memory> #define __cpp_­lib_­source_­location 201907L // also in <source_­location> #define __cpp_­lib_­span 202002L // also in <span> #define __cpp_­lib_­ssize 201902L // also in <iterator> #define __cpp_­lib_­starts_­ends_­with 201711L // also in <string>, <string_­view> #define __cpp_­lib_­string_­udls 201304L // also in <string> #define __cpp_­lib_­string_­view 201803L // also in <string>, <string_­view> #define __cpp_­lib_­syncbuf 201803L // also in <syncstream> #define __cpp_­lib_­three_­way_­comparison 201907L // also in <compare> #define __cpp_­lib_­to_­address 201711L // also in <memory> #define __cpp_­lib_­to_­array 201907L // also in <array> #define __cpp_­lib_­to_­chars 201611L // also in <charconv> #define __cpp_­lib_­transformation_­trait_­aliases 201304L // also in <type_­traits> #define __cpp_­lib_­transparent_­operators 201510L // also in <memory>, <functional> #define __cpp_­lib_­tuple_­element_­t 201402L // also in <tuple> #define __cpp_­lib_­tuples_­by_­type 201304L // also in <utility>, <tuple> #define __cpp_­lib_­type_­identity 201806L // also in <type_­traits> #define __cpp_­lib_­type_­trait_­variable_­templates 201510L // also in <type_­traits> #define __cpp_­lib_­uncaught_­exceptions 201411L // also in <exception> #define __cpp_­lib_­unordered_­map_­try_­emplace 201411L // also in <unordered_­map> #define __cpp_­lib_­unwrap_­ref 201811L // also in <type_­traits> #define __cpp_­lib_­variant 201606L // also in <variant> #define __cpp_­lib_­void_­t 201411L // also in <type_­traits>

17.3.3 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 T> class numeric_limits<const T>; template<class T> class numeric_limits<volatile T>; template<class T> class numeric_limits<const volatile T>; 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<char8_t>; 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>; }

17.3.4 Floating-point type properties [fp.style]

17.3.4.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 }; }
The rounding mode for floating-point arithmetic is characterized by the values:
  • round_­indeterminate if the rounding style is indeterminable
  • round_­toward_­zero if the rounding style is toward zero
  • round_­to_­nearest if the rounding style is to the nearest representable value
  • round_­toward_­infinity if the rounding style is toward infinity
  • round_­toward_­neg_­infinity if the rounding style is toward negative infinity

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

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

17.3.5 Class template numeric_­limits [numeric.limits]

17.3.5.1 General [numeric.limits.general]

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; }; }
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.
The default numeric_­limits<T> template shall have all members, but with 0 or false values.
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.
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.
Non-arithmetic standard types, such as complex<T>, shall not have specializations.

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

Each member function defined in this subclause is signal-safe.
static constexpr T min() noexcept;
Minimum finite value.185
For floating-point types with subnormal numbers, returns the minimum positive normalized value.
Meaningful for all specializations in which is_­bounded != false, or is_­bounded == false && is_­signed == false.
static constexpr T max() noexcept;
Maximum finite value.186
Meaningful for all specializations in which is_­bounded != false.
static constexpr T lowest() noexcept;
A finite value x such that there is no other finite value y where y < x.187
Meaningful for all specializations in which is_­bounded != false.
static constexpr int digits;
Number of radix digits that can be represented without change.
For integer types, the number of non-sign bits in the representation.
For floating-point types, the number of radix digits in the mantissa.188
static constexpr int digits10;
Number of base 10 digits that can be represented without change.189
Meaningful for all specializations in which is_­bounded != false.
static constexpr int max_digits10;
Number of base 10 digits required to ensure that values which differ are always differentiated.
Meaningful for all floating-point types.
static constexpr bool is_signed;
true if the type is signed.
Meaningful for all specializations.
static constexpr bool is_integer;
true if the type is integer.
Meaningful for all specializations.
static constexpr bool is_exact;
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.
Meaningful for all specializations.
static constexpr int radix;
For floating-point types, specifies the base or radix of the exponent representation (often 2).190
For integer types, specifies the base of the representation.191
Meaningful for all specializations.
static constexpr T epsilon() noexcept;
Machine epsilon: the difference between 1 and the least value greater than 1 that is representable.192
Meaningful for all floating-point types.
static constexpr T round_error() noexcept;
Measure of the maximum rounding error.193
static constexpr int min_exponent;
Minimum negative integer such that radix raised to the power of one less than that integer is a normalized floating-point number.194
Meaningful for all floating-point types.
static constexpr int min_exponent10;
Minimum negative integer such that 10 raised to that power is in the range of normalized floating-point numbers.195
Meaningful for all floating-point types.
static constexpr int max_exponent;
Maximum positive integer such that radix raised to the power one less than that integer is a representable finite floating-point number.196
Meaningful for all floating-point types.
static constexpr int max_exponent10;
Maximum positive integer such that 10 raised to that power is in the range of representable finite floating-point numbers.197
Meaningful for all floating-point types.
static constexpr bool has_infinity;
true if the type has a representation for positive infinity.
Meaningful for all floating-point types.
Shall be true for all specializations in which is_­iec559 != false.
static constexpr bool has_quiet_NaN;
true if the type has a representation for a quiet (non-signaling) “Not a Number”.198
Meaningful for all floating-point types.
Shall be true for all specializations in which is_­iec559 != false.
static constexpr bool has_signaling_NaN;
true if the type has a representation for a signaling “Not a Number”.199
Meaningful for all floating-point types.
Shall be true for all specializations in which is_­iec559 != false.
static constexpr float_denorm_style has_denorm;
denorm_­present if the type allows subnormal values (variable number of exponent bits)200, 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.
Meaningful for all floating-point types.
static constexpr bool has_denorm_loss;
true if loss of accuracy is detected as a denormalization loss, rather than as an inexact result.201
static constexpr T infinity() noexcept;
Representation of positive infinity, if available.202
Meaningful for all specializations for which has_­infinity != false.
Required in specializations for which is_­iec559 != false.
static constexpr T quiet_NaN() noexcept;
Representation of a quiet “Not a Number”, if available.203
Meaningful for all specializations for which has_­quiet_­NaN != false.
Required in specializations for which is_­iec559 != false.
static constexpr T signaling_NaN() noexcept;
Representation of a signaling “Not a Number”, if available.204
Meaningful for all specializations for which has_­signaling_­NaN != false.
Required in specializations for which is_­iec559 != false.
static constexpr T denorm_min() noexcept;
Minimum positive subnormal value.205
Meaningful for all floating-point types.
In specializations for which has_­denorm == false, returns the minimum positive normalized value.
static constexpr bool is_iec559;
true if and only if the type adheres to ISO/IEC/IEEE 60559.206
Meaningful for all floating-point types.
static constexpr bool is_bounded;
true if the set of values representable by the type is finite.207
[Note 1:
All fundamental types ([basic.fundamental]) are bounded.
This member would be false for arbitrary precision types.
— end note]
Meaningful for all specializations.
static constexpr bool is_modulo;
true if the type is modulo.208
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.
[Example 1:
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]
Meaningful for all specializations.
static constexpr bool traps;
true if, at the start of the program, there exists a value of the type that would cause an arithmetic operation using that value to trap.209
Meaningful for all specializations.
static constexpr bool tinyness_before;
true if tinyness is detected before rounding.210
Meaningful for all floating-point types.
static constexpr float_round_style round_style;
The rounding style for the type.211
Meaningful for all floating-point types.
Specializations for integer types shall return round_­toward_­zero.
Equivalent to CHAR_­MIN, SHRT_­MIN, FLT_­MIN, DBL_­MIN, etc.
 â®¥
Equivalent to CHAR_­MAX, SHRT_­MAX, FLT_­MAX, DBL_­MAX, etc.
 â®¥
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.
 â®¥
Equivalent to FLT_­MANT_­DIG, DBL_­MANT_­DIG, LDBL_­MANT_­DIG.
 â®¥
Equivalent to FLT_­DIG, DBL_­DIG, LDBL_­DIG.
 â®¥
Equivalent to FLT_­RADIX.
 â®¥
Distinguishes types with bases other than 2 (e.g. BCD).
 â®¥
Equivalent to FLT_­EPSILON, DBL_­EPSILON, LDBL_­EPSILON.
 â®¥
Rounding error is described in LIA-1 Section 5.2.4 and Annex C Rationale Section C.5.2.4 — Rounding and rounding constants.
 â®¥
Equivalent to FLT_­MIN_­EXP, DBL_­MIN_­EXP, LDBL_­MIN_­EXP.
 â®¥
Equivalent to FLT_­MIN_­10_­EXP, DBL_­MIN_­10_­EXP, LDBL_­MIN_­10_­EXP.
 â®¥
Equivalent to FLT_­MAX_­EXP, DBL_­MAX_­EXP, LDBL_­MAX_­EXP.
 â®¥
Equivalent to FLT_­MAX_­10_­EXP, DBL_­MAX_­10_­EXP, LDBL_­MAX_­10_­EXP.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
See ISO/IEC/IEEE 60559.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
ISO/IEC/IEEE 60559:2011 is the same as IEEE 754-2008.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
Required by LIA-1.
 â®¥
Refer to ISO/IEC/IEEE 60559.
Required by LIA-1.
 â®¥
Equivalent to FLT_­ROUNDS.
Required by LIA-1.
 â®¥

17.3.5.3 numeric_­limits specializations [numeric.special]

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.
[Example 1: 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]
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; }; }

17.3.6 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
The header <climits> defines all macros the same as the C standard library header <limits.h>.
[Note 1:
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

17.3.7 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
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