\rSec0[support]{Language support library}

\rSec1[support.general]{General}

This Clause describes the function signatures that are called

implicitly, and the types of objects generated implicitly, during the execution

of some \Cpp{} programs.

It also describes the headers that declare these function

signatures and define any related types.

The following subclauses describe

common type definitions used throughout the library,

characteristics of the predefined types,

functions supporting start and termination of a \Cpp{} program,

support for dynamic memory management,

support for dynamic type identification,

support for exception processing, support for initializer lists,

and other runtime support,

as summarized in \tref{support.summary}.

\begin{libsumtab}{Language support library summary}{support.summary}

\ref{support.types} & Common definitions &

\tcode{<cstddef>}, \tcode{<cstdlib>} \\ \rowsep

\ref{support.limits} & Implementation properties &

\tcode{<cfloat>}, \tcode{<climits>}, \tcode{<limits>}, \tcode{<version>} \\ \rowsep

\ref{support.arith.types} & Arithmetic types & \tcode{<cstdint>}, \tcode{<stdfloat>} \\ \rowsep

\ref{support.start.term} & Start and termination & \tcode{<cstdlib>} \\ \rowsep

\ref{support.dynamic} & Dynamic memory management & \tcode{<new>} \\ \rowsep

\ref{support.rtti} & Type identification & \tcode{<typeinfo>}, \tcode{<typeindex>} \\ \rowsep

\ref{support.srcloc} & Source location & \tcode{<source_location>} \\ \rowsep

\ref{support.exception} & Exception handling & \tcode{<exception>} \\ \rowsep

\ref{support.initlist} & Initializer lists & \tcode{<initializer_list>} \\ \rowsep

\ref{cmp} & Comparisons & \tcode{<compare>} \\ \rowsep

\ref{support.coroutine} & Coroutines & \tcode{<coroutine>} \\ \rowsep

\ref{support.runtime} & Other runtime support &

\tcode{<csetjmp>}, \tcode{<csignal>}, \tcode{<cstdarg>}, \tcode{<cstdlib>} \\

\end{libsumtab}

\rSec1[support.types]{Common definitions}

\rSec2[cstddef.syn]{Header \tcode{<cstddef>} synopsis}

\indexlibraryglobal{NULL}%

\indexlibraryglobal{offsetof}%

\indexlibraryglobal{ptrdiff_t}%

\indexlibraryglobal{size_t}%

\indexlibraryglobal{max_align_t}%

\indexlibraryglobal{nullptr_t}%

\indexlibraryglobal{byte}%

\begin{codeblock}

// all freestanding

namespace std {

using ptrdiff_t = @\seebelow@;

using size_t = @\seebelow@;

using max_align_t = @\seebelow@;

using nullptr_t = decltype(nullptr);

enum class byte : unsigned char {};

// \ref{support.types.byteops}, \tcode{byte} type operations

template<class IntType>

constexpr byte& operator<<=(byte& b, IntType shift) noexcept;

template<class IntType>

constexpr byte operator<<(byte b, IntType shift) noexcept;

template<class IntType>

constexpr byte& operator>>=(byte& b, IntType shift) noexcept;

template<class IntType>

constexpr byte operator>>(byte b, IntType shift) noexcept;

constexpr byte& operator|=(byte& l, byte r) noexcept;

constexpr byte operator|(byte l, byte r) noexcept;

constexpr byte& operator&=(byte& l, byte r) noexcept;

constexpr byte operator&(byte l, byte r) noexcept;

constexpr byte& operator^=(byte& l, byte r) noexcept;

constexpr byte operator^(byte l, byte r) noexcept;

constexpr byte operator~(byte b) noexcept;

template<class IntType>

constexpr IntType to_integer(byte b) noexcept;

}

#define NULL @\seebelow@

#define offsetof(P, D) @\seebelow@

\end{codeblock}

The contents and meaning of the header \libheaderdef{cstddef} are the same as

the C standard library header \libheader{stddef.h},

except that it does not declare the type \keyword{wchar_t},

that it also declares the type \tcode{byte}

and its associated operations\iref{support.types.byteops},

and as noted in

\ref{support.types.nullptr} and

\ref{support.types.layout}.

\xrefc{7.19}

\rSec2[cstdlib.syn]{Header \tcode{<cstdlib>} synopsis}

\indexheader{cstdlib}%

\indexlibraryglobal{EXIT_FAILURE}%

\indexlibraryglobal{EXIT_SUCCESS}%

\indexlibraryglobal{MB_CUR_MAX}%

\indexlibraryglobal{NULL}%

\indexlibraryglobal{RAND_MAX}%

\indexlibraryglobal{_Exit}%

\indexlibraryglobal{abort}%

\indexlibraryglobal{abs}%

\indexlibraryglobal{aligned_alloc}%

\indexlibraryglobal{at_quick_exit}%

\indexlibraryglobal{atexit}%

\indexlibraryglobal{atof}%

\indexlibraryglobal{atoi}%

\indexlibraryglobal{atol}%

\indexlibraryglobal{atoll}%

\indexlibraryglobal{bsearch}%

\indexlibraryglobal{calloc}%

\indexlibraryglobal{div}%

\indexlibraryglobal{div_t}%

\indexlibraryglobal{exit}%

\indexlibraryglobal{free}%

\indexlibraryglobal{getenv}%

\indexlibraryglobal{labs}%

\indexlibraryglobal{ldiv}%

\indexlibraryglobal{ldiv_t}%

\indexlibraryglobal{llabs}%

\indexlibraryglobal{lldiv}%

\indexlibraryglobal{lldiv_t}%

\indexlibraryglobal{malloc}%

\indexlibraryglobal{mblen}%

\indexlibraryglobal{mbstowcs}%

\indexlibraryglobal{mbtowc}%

\indexlibraryglobal{qsort}%

\indexlibraryglobal{quick_exit}%

\indexlibraryglobal{rand}%

\indexlibraryglobal{realloc}%

\indexlibraryglobal{size_t}%

\indexlibraryglobal{srand}%

\indexlibraryglobal{strtod}%

\indexlibraryglobal{strtof}%

\indexlibraryglobal{strtol}%

\indexlibraryglobal{strtold}%

\indexlibraryglobal{strtoll}%

\indexlibraryglobal{strtoul}%

\indexlibraryglobal{strtoull}%

\indexlibraryglobal{system}%

\indexlibraryglobal{wcstombs}%

\indexlibraryglobal{wctomb}%

\begin{codeblock}

namespace std {

using size_t = @\seebelow@; // freestanding

using div_t = @\seebelow@; // freestanding

using ldiv_t = @\seebelow@; // freestanding

using lldiv_t = @\seebelow@; // freestanding

}

#define NULL @\seebelow@ // freestanding

#define EXIT_FAILURE @\seebelow@ // freestanding

#define EXIT_SUCCESS @\seebelow@ // freestanding

#define RAND_MAX @\seebelow@

#define MB_CUR_MAX @\seebelow@

namespace std {

// Exposition-only function type aliases

extern "C" using @\placeholdernc{c-atexit-handler}@ = void(); // \expos

extern "C++" using @\placeholdernc{atexit-handler}@ = void(); // \expos

extern "C" using @\placeholdernc{c-compare-pred}@ = int(const void*, const void*); // \expos

extern "C++" using @\placeholdernc{compare-pred}@ = int(const void*, const void*); // \expos

// \ref{support.start.term}, start and termination

[[noreturn]] void abort() noexcept; // freestanding

int atexit(@\placeholder{c-atexit-handler}@* func) noexcept; // freestanding

int atexit(@\placeholder{atexit-handler}@* func) noexcept; // freestanding

int at_quick_exit(@\placeholder{c-atexit-handler}@* func) noexcept; // freestanding

int at_quick_exit(@\placeholder{atexit-handler}@* func) noexcept; // freestanding

[[noreturn]] void exit(int status); // freestanding

[[noreturn]] void _Exit(int status) noexcept; // freestanding

[[noreturn]] void quick_exit(int status) noexcept; // freestanding

char* getenv(const char* name);

int system(const char* string);

// \ref{c.malloc}, C library memory allocation

void* aligned_alloc(size_t alignment, size_t size);

void* calloc(size_t nmemb, size_t size);

void free(void* ptr);

void* malloc(size_t size);

void* realloc(void* ptr, size_t size);

double atof(const char* nptr);

int atoi(const char* nptr);

long int atol(const char* nptr);

long long int atoll(const char* nptr);

double strtod(const char* nptr, char** endptr);

float strtof(const char* nptr, char** endptr);

long double strtold(const char* nptr, char** endptr);

long int strtol(const char* nptr, char** endptr, int base);

long long int strtoll(const char* nptr, char** endptr, int base);

unsigned long int strtoul(const char* nptr, char** endptr, int base);

unsigned long long int strtoull(const char* nptr, char** endptr, int base);

// \ref{c.mb.wcs}, multibyte / wide string and character conversion functions

int mblen(const char* s, size_t n);

int mbtowc(wchar_t* pwc, const char* s, size_t n);

int wctomb(char* s, wchar_t wchar);

size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);

size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);

// \ref{alg.c.library}, C standard library algorithms

void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, // freestanding

@\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar);

void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, // freestanding

@\placeholder{compare-pred}@*@\itcorr[-1]@ compar);

void qsort(void* base, size_t nmemb, size_t size, @\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar); // freestanding

void qsort(void* base, size_t nmemb, size_t size, @\placeholder{compare-pred}@*@\itcorr[-1]@ compar); // freestanding

// \ref{c.math.rand}, low-quality random number generation

int rand();

void srand(unsigned int seed);

// \ref{c.math.abs}, absolute values

constexpr int abs(int j); // freestanding

constexpr long int abs(long int j); // freestanding

constexpr long long int abs(long long int j); // freestanding

constexpr @\placeholder{floating-point-type}@ abs(@\placeholder{floating-point-type}@ j); // freestanding-deleted

constexpr long int labs(long int j); // freestanding

constexpr long long int llabs(long long int j); // freestanding

constexpr div_t div(int numer, int denom); // freestanding

constexpr ldiv_t div(long int numer, long int denom); // freestanding; see \ref{library.c}

constexpr lldiv_t div(long long int numer, long long int denom); // freestanding; see \ref{library.c}

constexpr ldiv_t ldiv(long int numer, long int denom); // freestanding

constexpr lldiv_t lldiv(long long int numer, long long int denom); // freestanding

}

\end{codeblock}

The contents and meaning of the header \libheader{cstdlib} are the same as

the C standard library header \libheader{stdlib.h},

except that it does not declare the type \keyword{wchar_t},

and except as noted in

\ref{support.types.nullptr},

\ref{support.types.layout},

\ref{support.start.term},

\ref{c.malloc},

\ref{c.mb.wcs},

\ref{alg.c.library},

\ref{c.math.rand}, and

\ref{c.math.abs}.

\begin{note}

Several functions have additional overloads in this document,

but they have the same behavior as in the C standard library\iref{library.c}.

\end{note}

\xrefc{7.22}

\rSec2[support.types.nullptr]{Null pointers}

\indexlibraryglobal{nullptr_t}%

The type \tcode{nullptr_t} is a synonym

for the type of a \keyword{nullptr} expression, and it

has the characteristics

described in~\ref{basic.fundamental} and~\ref{conv.ptr}.

\begin{note}

Although \keyword{nullptr}'s address cannot be taken, the address of another

\tcode{nullptr_t} object that is an lvalue can be taken.

\end{note}

The macro

\indexlibraryglobal{NULL}%

\tcode{NULL}

is an \impldef{definition of \tcode{NULL}} null pointer constant.

\begin{footnote}

Possible definitions include

\tcode{0}

and

\tcode{0L},

but not

\tcode{(void*)0}.

\end{footnote}

\xrefc{7.19}

\rSec2[support.types.layout]{Sizes, alignments, and offsets}

The macro

\indexlibraryglobal{offsetof}%

\tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}

has the same semantics as the corresponding macro in

the C standard library header \libheader{stddef.h}, but

accepts a restricted set of \tcode{\placeholder{type}}

arguments in this document.

Use of the \tcode{offsetof} macro with a \tcode{\placeholder{type}}

other than a standard-layout class\iref{class.prop}

is conditionally-supported.

\begin{footnote}

Note that \tcode{offsetof}

is required to work as specified even if unary

\tcode{operator\&}

is overloaded for any of the types involved.

\end{footnote}

The expression \tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}

is never type-dependent\iref{temp.dep.expr} and it is

value-dependent\iref{temp.dep.constexpr} if and only if \tcode{\placeholder{type}} is

dependent. The result of applying the \tcode{offsetof} macro to

a static data member or a function member is undefined.

No operation invoked by the \tcode{offsetof} macro shall throw an exception and

\tcode{noexcept(offsetof(\placeholder{type}, \placeholder{member-designator}))} shall be \tcode{true}.

The type \tcode{ptrdiff_t} is an

\impldef{type of \tcode{ptrdiff_t}}

signed integer type that can

hold the difference of two subscripts in an array object, as described in~\ref{expr.add}.

The type \tcode{size_t} is an

\impldef{type of \tcode{size_t}}

unsigned integer type that is large enough

to contain the size in bytes of any object\iref{expr.sizeof}.

An implementation should choose types for \tcode{ptrdiff_t} and \tcode{size_t}

whose integer conversion ranks\iref{conv.rank} are no greater than that of

\tcode{signed long int} unless a larger size is necessary to contain all the possible values.

The type

\indexlibraryglobal{max_align_t}%

\tcode{max_align_t} is a trivial standard-layout type whose alignment requirement

is at least as great as that of every scalar type, and whose alignment

requirement is supported in every context\iref{basic.align}.

\xrefc{7.19}

\rSec2[support.types.byteops]{\tcode{byte} type operations}

\indexlibrarymember{operator<<=}{byte}%

\begin{itemdecl}

template<class IntType>

constexpr byte& operator<<=(byte& b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{is_integral_v<IntType>} is \tcode{true}.

Equivalent to:

\tcode{return b = b << shift;}

\end{itemdescr}

\indexlibrarymember{operator<<}{byte}%

\begin{itemdecl}

template<class IntType>

constexpr byte operator<<(byte b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{is_integral_v<IntType>} is \tcode{true}.

Equivalent to:

\begin{codeblock}

return static_cast<byte>(static_cast<unsigned int>(b) << shift);

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator>>=}{byte}%

\begin{itemdecl}

template<class IntType>

constexpr byte& operator>>=(byte& b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{is_integral_v<IntType>} is \tcode{true}.

Equivalent to:

\tcode{return b = b >> shift;}

\end{itemdescr}

\indexlibrarymember{operator>>}{byte}%

\begin{itemdecl}

template<class IntType>

constexpr byte operator>>(byte b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{is_integral_v<IntType>} is \tcode{true}.

Equivalent to:

\begin{codeblock}

return static_cast<byte>(static_cast<unsigned int>(b) >> shift);

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator"|=}{byte}%

\begin{itemdecl}

constexpr byte& operator|=(byte& l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{return l = l | r;}

\end{itemdescr}

\indexlibrarymember{operator"|}{byte}%

\begin{itemdecl}

constexpr byte operator|(byte l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to:

\begin{codeblock}

return static_cast<byte>(static_cast<unsigned int>(l) | static_cast<unsigned int>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\&=}{byte}%

\begin{itemdecl}

constexpr byte& operator&=(byte& l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{return l = l \& r;}

\end{itemdescr}

\indexlibrarymember{operator\&}{byte}%

\begin{itemdecl}

constexpr byte operator&(byte l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to:

\begin{codeblock}

return static_cast<byte>(static_cast<unsigned int>(l) & static_cast<unsigned int>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\caret=}{byte}%

\begin{itemdecl}

constexpr byte& operator^=(byte& l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to: \tcode{return l = l \caret{} r;}

\end{itemdescr}

\indexlibrarymember{operator\caret}{byte}%

\begin{itemdecl}

constexpr byte operator^(byte l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to:

\begin{codeblock}

return static_cast<byte>(static_cast<unsigned int>(l) ^ static_cast<unsigned int>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\~{}}{byte}%

\begin{itemdecl}

constexpr byte operator~(byte b) noexcept;

\end{itemdecl}

\begin{itemdescr}

Equivalent to:

\begin{codeblock}

return static_cast<byte>(~static_cast<unsigned int>(b));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{to_integer}{byte}%

\begin{itemdecl}

template<class IntType>

constexpr IntType to_integer(byte b) noexcept;

\end{itemdecl}

\begin{itemdescr}

\tcode{is_integral_v<IntType>} is \tcode{true}.

Equivalent to: \tcode{return static_cast<IntType>(b);}

\end{itemdescr}

\rSec1[support.limits]{Implementation properties}

\rSec2[support.limits.general]{General}

The headers

\libheaderref{limits},

\libheaderref{climits}, and

\libheaderref{cfloat}

supply characteristics of

\indextext{implementation-dependent}%

imple\-mentation-dependent

arithmetic types\iref{basic.fundamental}.

\rSec2[version.syn]{Header \tcode{<version>} synopsis}

The header \libheaderdef{version}

supplies implementation-dependent information

about the \Cpp{} standard library

(e.g., version number and release date).

\indextext{macro!feature-test}%

Each of the macros defined in \libheader{version} is also defined

after inclusion of any member of the set of library headers

indicated in the corresponding comment in this synopsis.

\begin{note}

Future revisions of this document might replace

the values of these macros with greater values.

\end{note}

\begin{codeblock}

#define @\defnlibxname{cpp_lib_adaptor_iterator_pair_constructor}@ 202106L // also in \libheader{stack}, \libheader{queue}

#define @\defnlibxname{cpp_lib_addressof_constexpr}@ 201603L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_algorithm_default_value_type}@ 202403L

// also in \libheader{algorithm}, \libheader{ranges}, \libheader{string}, \libheader{deque}, \libheader{list}, \libheader{forward_list}, \libheader{vector}

#define @\defnlibxname{cpp_lib_algorithm_iterator_requirements}@ 202207L

// also in \libheader{algorithm}, \libheader{numeric}, \libheader{memory}

#define @\defnlibxname{cpp_lib_allocate_at_least}@ 202302L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_allocator_traits_is_always_equal}@ 201411L

// freestanding, also in \libheader{memory}, \libheader{scoped_allocator}, \libheader{string}, \libheader{deque}, \libheader{forward_list}, \libheader{list},

// \libheader{vector}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}

#define @\defnlibxname{cpp_lib_any}@ 201606L // also in \libheader{any}

#define @\defnlibxname{cpp_lib_apply}@ 201603L // freestanding, also in \libheader{tuple}

#define @\defnlibxname{cpp_lib_array_constexpr}@ 201811L // also in \libheader{iterator}, \libheader{array}

#define @\defnlibxname{cpp_lib_as_const}@ 201510L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_associative_heterogeneous_erasure}@ 202110L

// also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}

#define @\defnlibxname{cpp_lib_associative_heterogeneous_insertion}@ 202306L

// also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}

#define @\defnlibxname{cpp_lib_assume_aligned}@ 201811L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_atomic_flag_test}@ 201907L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_float}@ 201711L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_is_always_lock_free}@ 201603L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_lock_free_type_aliases}@ 201907L // also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_min_max}@ 202403L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_ref}@ 201806L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_shared_ptr}@ 201711L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_atomic_value_initialization}@ 201911L // freestanding, also in \libheader{atomic}, \libheader{memory}

#define @\defnlibxname{cpp_lib_atomic_wait}@ 201907L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_barrier}@ 202302L // also in \libheader{barrier}

#define @\defnlibxname{cpp_lib_bind_back}@ 202306L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_bind_front}@ 202306L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_bit_cast}@ 201806L // freestanding, also in \libheader{bit}

#define @\defnlibxname{cpp_lib_bitops}@ 201907L // freestanding, also in \libheader{bit}

#define @\defnlibxname{cpp_lib_bitset}@ 202306L // also in \libheader{bitset}

#define @\defnlibxname{cpp_lib_bool_constant}@ 201505L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_bounded_array_traits}@ 201902L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_boyer_moore_searcher}@ 201603L // also in \libheader{functional}

#define @\defnlibxname{cpp_lib_byte}@ 201603L // freestanding, also in \libheader{cstddef}

#define @\defnlibxname{cpp_lib_byteswap}@ 202110L // freestanding, also in \libheader{bit}

#define @\defnlibxname{cpp_lib_char8_t}@ 201907L

// freestanding, also in \libheader{atomic}, \libheader{filesystem}, \libheader{istream}, \libheader{limits}, \libheader{locale}, \libheader{ostream}, \libheader{string},

// \libheader{string_view}

#define @\defnlibxname{cpp_lib_chrono}@ 202306L // also in \libheader{chrono}

#define @\defnlibxname{cpp_lib_chrono_udls}@ 201304L // also in \libheader{chrono}

#define @\defnlibxname{cpp_lib_clamp}@ 201603L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_common_reference}@ 202302L // also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_common_reference_wrapper}@ 202302L // also in \libheader{functional}

#define @\defnlibxname{cpp_lib_complex_udls}@ 201309L // also in \libheader{complex}

#define @\defnlibxname{cpp_lib_concepts}@ 202207L

// freestanding, also in \libheader{concepts}, \libheader{compare}

#define @\defnlibxname{cpp_lib_constexpr_algorithms}@ 202306L // also in \libheader{algorithm}, \libheader{utility}

#define @\defnlibxname{cpp_lib_constexpr_bitset}@ 202207L // also in \libheader{bitset}

#define @\defnlibxname{cpp_lib_constexpr_charconv}@ 202207L // also in \libheader{charconv}

#define @\defnlibxname{cpp_lib_constexpr_cmath}@ 202306L // also in \libheader{cmath}, \libheader{cstdlib}

#define @\defnlibxname{cpp_lib_constexpr_complex}@ 202306L // also in \libheader{complex}

#define @\defnlibxname{cpp_lib_constexpr_dynamic_alloc}@ 201907L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_constexpr_functional}@ 201907L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_constexpr_iterator}@ 201811L // freestanding, also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_constexpr_memory}@ 202202L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_constexpr_new}@ 202406L // freestanding, also in \libheader{new}

#define @\defnlibxname{cpp_lib_constexpr_numeric}@ 201911L // also in \libheader{numeric}

#define @\defnlibxname{cpp_lib_constexpr_string}@ 201907L // also in \libheader{string}

#define @\defnlibxname{cpp_lib_constexpr_string_view}@ 201811L // also in \libheader{string_view}

#define @\defnlibxname{cpp_lib_constexpr_tuple}@ 201811L // freestanding, also in \libheader{tuple}

#define @\defnlibxname{cpp_lib_constexpr_typeinfo}@ 202106L // freestanding, also in \libheader{typeinfo}

#define @\defnlibxname{cpp_lib_constexpr_utility}@ 201811L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_constexpr_vector}@ 201907L // also in \libheader{vector}

#define @\defnlibxname{cpp_lib_constrained_equality}@ 202403L // freestanding,

// also in \libheader{utility}, \libheader{tuple}, \libheader{optional}, \libheader{variant}

#define @\defnlibxname{cpp_lib_containers_ranges}@ 202202L

// also in \libheader{vector}, \libheader{list}, \libheader{forward_list}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set},

// \libheader{deque}, \libheader{queue}, \libheader{stack}, \libheader{string}

#define @\defnlibxname{cpp_lib_copyable_function}@ 202306L // also in \libheader{functional}

#define @\defnlibxname{cpp_lib_coroutine}@ 201902L // also in \libheader{coroutine}

#define @\defnlibxname{cpp_lib_debugging}@ 202403L // freestanding, also in \libheader{debugging}

#define @\defnlibxname{cpp_lib_destroying_delete}@ 201806L // freestanding, also in \libheader{new}

#define @\defnlibxname{cpp_lib_enable_shared_from_this}@ 201603L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_endian}@ 201907L // freestanding, also in \libheader{bit}

#define @\defnlibxname{cpp_lib_erase_if}@ 202002L

// also in \libheader{string}, \libheader{deque}, \libheader{forward_list}, \libheader{list}, \libheader{vector}, \libheader{map}, \libheader{set}, \libheader{unordered_map},

// \libheader{unordered_set}

#define @\defnlibxname{cpp_lib_exchange_function}@ 201304L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_execution}@ 201902L // also in \libheader{execution}

#define @\defnlibxname{cpp_lib_expected}@ 202211L // also in \libheader{expected}

#define @\defnlibxname{cpp_lib_filesystem}@ 201703L // also in \libheader{filesystem}

#define @\defnlibxname{cpp_lib_flat_map}@ 202207L // also in \libheader{flat_map}

#define @\defnlibxname{cpp_lib_flat_set}@ 202207L // also in \libheader{flat_set}

#define @\defnlibxname{cpp_lib_format}@ 202311L // also in \libheader{format}

#define @\defnlibxname{cpp_lib_format_ranges}@ 202207L // also in \libheader{format}

#define @\defnlibxname{cpp_lib_format_path}@ 202403L // also in \libheader{filesystem}

#define @\defnlibxname{cpp_lib_format_uchar}@ 202311L // also in \libheader{format}

#define @\defnlibxname{cpp_lib_formatters}@ 202302L // also in \libheader{stacktrace}, \libheader{thread}

#define @\defnlibxname{cpp_lib_forward_like}@ 202207L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_freestanding_algorithm}@ 202311L // freestanding, also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_freestanding_array}@ 202311L // freestanding, also in \libheader{array}

#define @\defnlibxname{cpp_lib_freestanding_char_traits}@ 202306L // freestanding, also in \libheader{string}

#define @\defnlibxname{cpp_lib_freestanding_charconv}@ 202306L // freestanding, also in \libheader{charconv}

#define @\defnlibxname{cpp_lib_freestanding_cstdlib}@ 202306L // freestanding, also in \libheader{cstdlib}, \libheader{cmath}

#define @\defnlibxname{cpp_lib_freestanding_cstring}@ 202311L // freestanding, also in \libheader{cstring}

#define @\defnlibxname{cpp_lib_freestanding_cwchar}@ 202306L // freestanding, also in \libheader{cwchar}

#define @\defnlibxname{cpp_lib_freestanding_errc}@ 202306L

// freestanding, also in \libheader{cerrno}, \libheader{system_error}

#define @\defnlibxname{cpp_lib_freestanding_expected}@ 202311L // freestanding, also in \libheader{expected}

#define @\defnlibxname{cpp_lib_freestanding_feature_test_macros}@ 202306L // freestanding

#define @\defnlibxname{cpp_lib_freestanding_functional}@ 202306L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_freestanding_iterator}@ 202306L // freestanding, also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_freestanding_mdspan}@ 202311L // freestanding, also in \libheader{mdspan}

#define @\defnlibxname{cpp_lib_freestanding_memory}@ 202306L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_freestanding_numeric}@ 202311L // freestanding, also in \libheader{numeric}

#define @\defnlibxname{cpp_lib_freestanding_operator_new}@ @\seebelow@ // freestanding, also in \libheader{new}

#define @\defnlibxname{cpp_lib_freestanding_optional}@ 202311L // freestanding, also in \libheader{optional}

#define @\defnlibxname{cpp_lib_freestanding_ranges}@ 202306L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_freestanding_ratio}@ 202306L // freestanding, also in \libheader{ratio}

#define @\defnlibxname{cpp_lib_freestanding_string_view}@ 202311L // freestanding, also in \libheader{string_view}

#define @\defnlibxname{cpp_lib_freestanding_tuple}@ 202306L // freestanding, also in \libheader{tuple}

#define @\defnlibxname{cpp_lib_freestanding_utility}@ 202306L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_freestanding_variant}@ 202311L // freestanding, also in \libheader{variant}

#define @\defnlibxname{cpp_lib_fstream_native_handle}@ 202306L // also in \libheader{fstream}

#define @\defnlibxname{cpp_lib_function_ref}@ 202306L // also in \libheader{functional}

#define @\defnlibxname{cpp_lib_gcd_lcm}@ 201606L // also in \libheader{numeric}

#define @\defnlibxname{cpp_lib_generator}@ 202207L // also in \libheader{generator}

#define @\defnlibxname{cpp_lib_generic_associative_lookup}@ 201304L // also in \libheader{map}, \libheader{set}

#define @\defnlibxname{cpp_lib_generic_unordered_lookup}@ 201811L

// also in \libheader{unordered_map}, \libheader{unordered_set}

#define @\defnlibxname{cpp_lib_hardware_interference_size}@ 201703L // freestanding, also in \libheader{new}

#define @\defnlibxname{cpp_lib_has_unique_object_representations}@ 201606L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_hazard_pointer}@ 202306L // also in \libheader{hazard_pointer}

#define @\defnlibxname{cpp_lib_hypot}@ 201603L // also in \libheader{cmath}

#define @\defnlibxname{cpp_lib_incomplete_container_elements}@ 201505L

// also in \libheader{forward_list}, \libheader{list}, \libheader{vector}

#define @\defnlibxname{cpp_lib_inplace_vector}@ 202406L // also in \libheader{inplace_vector}

#define @\defnlibxname{cpp_lib_int_pow2}@ 202002L // freestanding, also in \libheader{bit}

#define @\defnlibxname{cpp_lib_integer_comparison_functions}@ 202002L // also in \libheader{utility}

#define @\defnlibxname{cpp_lib_integer_sequence}@ 201304L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_integral_constant_callable}@ 201304L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_interpolate}@ 201902L // also in \libheader{cmath}, \libheader{numeric}

#define @\defnlibxname{cpp_lib_invoke}@ 201411L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_invoke_r}@ 202106L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_ios_noreplace}@ 202207L // also in \libheader{ios}

#define @\defnlibxname{cpp_lib_is_aggregate}@ 201703L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_constant_evaluated}@ 201811L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_final}@ 201402L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_implicit_lifetime}@ 202302L // also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_invocable}@ 201703L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_layout_compatible}@ 201907L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_nothrow_convertible}@ 201806L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_null_pointer}@ 201309L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_pointer_interconvertible}@ 201907L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_scoped_enum}@ 202011L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_swappable}@ 201603L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_virtual_base_of}@ 202406L // also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_within_lifetime}@ 202306L // also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_jthread}@ 201911L // also in \libheader{stop_token}, \libheader{thread}

#define @\defnlibxname{cpp_lib_latch}@ 201907L // also in \libheader{latch}

#define @\defnlibxname{cpp_lib_launder}@ 201606L // freestanding, also in \libheader{new}

#define @\defnlibxname{cpp_lib_linalg}@ 202311L // also in \libheader{linalg}

#define @\defnlibxname{cpp_lib_list_remove_return_type}@ 201806L // also in \libheader{forward_list}, \libheader{list}

#define @\defnlibxname{cpp_lib_logical_traits}@ 201510L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_make_from_tuple}@ 201606L // freestanding, also in \libheader{tuple}

#define @\defnlibxname{cpp_lib_make_reverse_iterator}@ 201402L // freestanding, also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_make_unique}@ 201304L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_map_try_emplace}@ 201411L // also in \libheader{map}

#define @\defnlibxname{cpp_lib_math_constants}@ 201907L // also in \libheader{numbers}

#define @\defnlibxname{cpp_lib_math_special_functions}@ 201603L // also in \libheader{cmath}

#define @\defnlibxname{cpp_lib_mdspan}@ 202406L // also in \libheader{mdspan}

#define @\defnlibxname{cpp_lib_memory_resource}@ 201603L // also in \libheader{memory_resource}

#define @\defnlibxname{cpp_lib_modules}@ 202207L // freestanding

#define @\defnlibxname{cpp_lib_move_iterator_concept}@ 202207L // freestanding, also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_move_only_function}@ 202110L // also in \libheader{functional}

#define @\defnlibxname{cpp_lib_node_extract}@ 201606L

// also in \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}

#define @\defnlibxname{cpp_lib_nonmember_container_access}@ 201411L

// freestanding, also in \libheader{array}, \libheader{deque}, \libheader{forward_list}, \libheader{iterator}, \libheader{list}, \libheader{map}, \libheader{regex}, \libheader{set},

// \libheader{string}, \libheader{unordered_map}, \libheader{unordered_set}, \libheader{vector}

#define @\defnlibxname{cpp_lib_not_fn}@ 202306L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_null_iterators}@ 201304L // freestanding, also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_optional}@ 202110L // also in \libheader{optional}

#define @\defnlibxname{cpp_lib_optional_range_support}@ 202406L // freestanding, also in \libheader{optional}

#define @\defnlibxname{cpp_lib_out_ptr}@ 202311L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_parallel_algorithm}@ 201603L // also in \libheader{algorithm}, \libheader{numeric}

#define @\defnlibxname{cpp_lib_philox_engine}@ 202406L // also in \libheader{random}

#define @\defnlibxname{cpp_lib_polymorphic_allocator}@ 201902L // also in \libheader{memory_resource}

#define @\defnlibxname{cpp_lib_print}@ 202406L // also in \libheader{print}, \libheader{ostream}

#define @\defnlibxname{cpp_lib_quoted_string_io}@ 201304L // also in \libheader{iomanip}

#define @\defnlibxname{cpp_lib_ranges}@ 202406L

// also in \libheader{algorithm}, \libheader{functional}, \libheader{iterator}, \libheader{memory}, \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_as_const}@ 202311L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_as_rvalue}@ 202207L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_cartesian_product}@ 202207L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_chunk}@ 202202L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_chunk_by}@ 202202L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_concat}@ 202403L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_contains}@ 202207L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_ranges_enumerate}@ 202302L // also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_find_last}@ 202207L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_ranges_fold}@ 202207L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_ranges_generate_random}@ 202403L // also in \libheader{random}

#define @\defnlibxname{cpp_lib_ranges_iota}@ 202202L // also in \libheader{numeric}

#define @\defnlibxname{cpp_lib_ranges_join_with}@ 202202L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_repeat}@ 202207L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_slide}@ 202202L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_starts_ends_with}@ 202106L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_ranges_stride}@ 202207L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_to_container}@ 202202L // freestanding, also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_zip}@ 202110L

// freestanding, also in \libheader{ranges}, \libheader{tuple}, \libheader{utility}

#define @\defnlibxname{cpp_lib_ratio}@ 202306L // also in \libheader{ratio}

#define @\defnlibxname{cpp_lib_raw_memory_algorithms}@ 201606L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_rcu}@ 202306L // also in \libheader{rcu}

#define @\defnlibxname{cpp_lib_reference_from_temporary}@ 202202L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_reference_wrapper}@ 202403L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_remove_cvref}@ 201711L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_result_of_sfinae}@ 201210L

// freestanding, also in \libheader{functional}, \libheader{type_traits}

#define @\defnlibxname{cpp_lib_robust_nonmodifying_seq_ops}@ 201304L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_sample}@ 201603L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_saturation_arithmetic}@ 202311L // also in \libheader{numeric}

#define @\defnlibxname{cpp_lib_scoped_lock}@ 201703L // also in \libheader{mutex}

#define @\defnlibxname{cpp_lib_semaphore}@ 201907L // also in \libheader{semaphore}

#define @\defnlibxname{cpp_lib_senders}@ 202406L // also in \libheader{execution}

#define @\defnlibxname{cpp_lib_shared_mutex}@ 201505L // also in \libheader{shared_mutex}

#define @\defnlibxname{cpp_lib_shared_ptr_arrays}@ 201707L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_shared_ptr_weak_type}@ 201606L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_shared_timed_mutex}@ 201402L // also in \libheader{shared_mutex}

#define @\defnlibxname{cpp_lib_shift}@ 202202L // also in \libheader{algorithm}

#define @\defnlibxname{cpp_lib_smart_ptr_for_overwrite}@ 202002L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_smart_ptr_owner_equality}@ 202306L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_source_location}@ 201907L // freestanding, also in \libheader{source_location}

#define @\defnlibxname{cpp_lib_span}@ 202311L // freestanding, also in \libheader{span}

#define @\defnlibxname{cpp_lib_span_initializer_list}@ 202311L // also in \libheader{span}

#define @\defnlibxname{cpp_lib_spanstream}@ 202106L // also in \libheader{spanstream}

#define @\defnlibxname{cpp_lib_ssize}@ 201902L // freestanding, also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_sstream_from_string_view}@ 202306L // also in \libheader{sstream}

#define @\defnlibxname{cpp_lib_stacktrace}@ 202011L // also in \libheader{stacktrace}

#define @\defnlibxname{cpp_lib_start_lifetime_as}@ 202207L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_starts_ends_with}@ 201711L // also in \libheader{string}, \libheader{string_view}

#define @\defnlibxname{cpp_lib_stdatomic_h}@ 202011L // also in \libheader{stdatomic.h}

#define @\defnlibxname{cpp_lib_string_contains}@ 202011L // also in \libheader{string}, \libheader{string_view}

#define @\defnlibxname{cpp_lib_string_resize_and_overwrite}@ 202110L // also in \libheader{string}

#define @\defnlibxname{cpp_lib_string_udls}@ 201304L // also in \libheader{string}

#define @\defnlibxname{cpp_lib_string_view}@ 202403L // also in \libheader{string}, \libheader{string_view}

#define @\defnlibxname{cpp_lib_submdspan}@ 202403L // also in \libheader{mdspan}

#define @\defnlibxname{cpp_lib_syncbuf}@ 201803L // also in \libheader{syncstream}

#define @\defnlibxname{cpp_lib_text_encoding}@ 202306L // also in \libheader{text_encoding}

#define @\defnlibxname{cpp_lib_three_way_comparison}@ 201907L // freestanding, also in \libheader{compare}

#define @\defnlibxname{cpp_lib_to_address}@ 201711L // freestanding, also in \libheader{memory}

#define @\defnlibxname{cpp_lib_to_array}@ 201907L // also in \libheader{array}

#define @\defnlibxname{cpp_lib_to_chars}@ 202306L // also in \libheader{charconv}

#define @\defnlibxname{cpp_lib_to_string}@ 202306L // also in \libheader{string}

#define @\defnlibxname{cpp_lib_to_underlying}@ 202102L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_transformation_trait_aliases}@ 201304L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_transparent_operators}@ 201510L

// freestanding, also in \libheader{memory}, \libheader{functional}

#define @\defnlibxname{cpp_lib_tuple_element_t}@ 201402L // freestanding, also in \libheader{tuple}

#define @\defnlibxname{cpp_lib_tuple_like}@ 202311L

// also in \libheader{utility}, \libheader{tuple}, \libheader{map}, \libheader{unordered_map}

#define @\defnlibxname{cpp_lib_tuples_by_type}@ 201304L // freestanding, also in \libheader{utility}, \libheader{tuple}

#define @\defnlibxname{cpp_lib_type_identity}@ 201806L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_type_trait_variable_templates}@ 201510L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_uncaught_exceptions}@ 201411L // freestanding, also in \libheader{exception}

#define @\defnlibxname{cpp_lib_unordered_map_try_emplace}@ 201411L // also in \libheader{unordered_map}

#define @\defnlibxname{cpp_lib_unreachable}@ 202202L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_unwrap_ref}@ 201811L // freestanding, also in \libheader{type_traits}

#define @\defnlibxname{cpp_lib_variant}@ 202306L // also in \libheader{variant}

#define @\defnlibxname{cpp_lib_void_t}@ 201411L // freestanding, also in \libheader{type_traits}

\end{codeblock}

The macro \xname{cpp_lib_freestanding_operator_new} is defined to

the integer literal \tcode{202306L}

if all the default versions of the replaceable global allocation functions meet

the requirements of a hosted implementation, and

to the integer literal \tcode{0} otherwise\iref{new.delete}.

Freestanding implementations should only define a macro from \libheader{version}

if the implementation provides the corresponding facility in its entirety.

\rSec2[limits.syn]{Header \tcode{<limits>} synopsis}

\indexheader{limits}%

\indextext{\idxcode{numeric_limits}}%

\indexlibraryglobal{numeric_limits}%

\indexlibraryglobal{float_round_style}%

\begin{codeblock}

// all freestanding

namespace std {

// \ref{round.style}, enumeration \tcode{float_round_style}

enum float_round_style;

// \ref{numeric.limits}, class template \tcode{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>;

}

\end{codeblock}

\rSec2[round.style]{Enum \tcode{float_round_style}}

\indexlibraryglobal{float_round_style}%

\begin{codeblock}

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

};

}

\end{codeblock}

The rounding mode for floating-point arithmetic is characterized by the

values:

\begin{itemize}

\indexlibraryglobal{round_indeterminate}%

\tcode{round_indeterminate}

if the rounding style is indeterminable

\indexlibraryglobal{round_toward_zero}%

\tcode{round_toward_zero}

if the rounding style is toward zero

\indexlibraryglobal{round_to_nearest}%

\tcode{round_to_nearest}

if the rounding style is to the nearest representable value

\indexlibraryglobal{round_toward_infinity}%

\tcode{round_toward_infinity}

if the rounding style is toward infinity

\indexlibraryglobal{round_toward_neg_infinity}%

\tcode{round_toward_neg_infinity}

if the rounding style is toward negative infinity

\end{itemize}

\rSec2[numeric.limits]{Class template \tcode{numeric_limits}}

\rSec3[numeric.limits.general]{General}

The

\indexlibraryglobal{numeric_limits}%

\tcode{numeric_limits}

class template provides a \Cpp{} program with information about various properties of

the implementation's representation of the

arithmetic types.

\indexlibraryglobal{numeric_limits}%

\begin{codeblock}

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

};

}

\end{codeblock}

For all members declared

\keyword{static} \keyword{constexpr}

in the

\tcode{numeric_limits}

template, specializations shall define these values in such a way

that they are usable as

constant expressions.

For the

\tcode{numeric_limits}

primary template, all data members are value-initialized and all

member functions return a value-initialized object.

\begin{note}

This means all members have zero or \tcode{false} values

unless \tcode{numeric_limits} is specialized for a type.

\end{note}

Specializations shall be provided for each

arithmetic type,

both floating-point and integer, including

\tcode{bool}.

The member

\tcode{is_specialized}