\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 contract-violation handling,

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.contract} & Contract-violation handling & \tcode{<contracts>} \\ \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}

\begin{codeblock}

// all freestanding

namespace std {

using @\libglobal{ptrdiff_t}@ = @\seebelow@;

using @\libglobal{size_t}@ = @\seebelow@;

using @\libglobal{max_align_t}@ = @\seebelow@;

using @\libglobal{nullptr_t}@ = decltype(nullptr);

enum class @\libglobal{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 @\libglobal{NULL}@ @\seebelow@

#define @\libglobal{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 does not define the macro \tcode{unreachable},

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.21}

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

\indexheader{cstdlib}%

\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{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 @\libglobal{NULL}@ @\seebelow@ // freestanding

#define @\libglobal{EXIT_FAILURE}@ @\seebelow@ // freestanding

#define @\libglobal{EXIT_SUCCESS}@ @\seebelow@ // freestanding

#define @\libglobal{RAND_MAX}@ @\seebelow@

#define @\libglobal{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* @\libglobal{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 free_sized(void* ptr, size_t size);

void free_aligned_sized(void* ptr, size_t alignment, size_t size);

void* malloc(size_t size);

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

size_t memalignment(const void* p); // freestanding

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

int strfromd(char* s, size_t n, const char* format, double fp);

int strfromf(char* s, size_t n, const char* format, float fp);

int strfroml(char* s, size_t n, const char* format, long double fp);

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, void* base, size_t nmemb, size_t size, // freestanding

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

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

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

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

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

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

size_t size, @\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 types \keyword{wchar_t} or \tcode{once_flag},

and does not declare the function \tcode{call_once},

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 \link{C standard library}{library.c}.

\end{note}

\xrefc{7.24}

\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.21}

\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 \link{type-dependent}{temp.dep.expr} and it is

\link{value-dependent}{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 trivially copyable 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}.

\tcode{std::is_trivially_default_constructible_v<max_align_t>} is \tcode{true}.

\xrefc{7.21}

\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}@ 202603L

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

#define @\defnlibxname{cpp_lib_algorithm_iterator_requirements}@ 202207L

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

#define @\defnlibxname{cpp_lib_aligned_accessor}@ 202411L // freestanding, also in \libheader{mdspan}

#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}@ 202506L

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

#define @\defnlibxname{cpp_lib_array_constexpr}@ 201811L

// freestanding, 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}@ 202506L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_reductions}@ 202506L // freestanding, also in \libheader{atomic}

#define @\defnlibxname{cpp_lib_atomic_ref}@ 202603L // 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{iosfwd}, \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 // freestanding, also in \libheader{algorithm}

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

#define @\defnlibxname{cpp_lib_common_reference_wrapper}@ 202302L // freestanding, 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_constant_wrapper}@ 202603L // freestanding, also in \libheader{utility}

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

#define @\defnlibxname{cpp_lib_constexpr_atomic}@ 202411L // also in \libheader{atomic}

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

#define @\defnlibxname{cpp_lib_constexpr_charconv}@ 202207L // freestanding, 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_deque}@ 202502L // also in \libheader{deque}

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

#define @\defnlibxname{cpp_lib_constexpr_exceptions}@ 202502L

// also in \libheader{exception}, \libheader{stdexcept}, \libheader{expected}, \libheader{optional}, \libheader{variant}, and \libheader{format}

#define @\defnlibxname{cpp_lib_constexpr_flat_map}@ 202502L // also in \libheader{flat_map}

#define @\defnlibxname{cpp_lib_constexpr_flat_set}@ 202502L // also in \libheader{flat_set}

#define @\defnlibxname{cpp_lib_constexpr_format}@ 202511L // also in \libheader{format}

#define @\defnlibxname{cpp_lib_constexpr_forward_list}@ 202502L // also in \libheader{forward_list}

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

#define @\defnlibxname{cpp_lib_constexpr_inplace_vector}@ 202502L // also in \libheader{inplace_vector}

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

#define @\defnlibxname{cpp_lib_constexpr_list}@ 202502L // also in \libheader{list}

#define @\defnlibxname{cpp_lib_constexpr_map}@ 202502L // also in \libheader{map}

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

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

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

#define @\defnlibxname{cpp_lib_constexpr_queue}@ 202502L // also in \libheader{queue}

#define @\defnlibxname{cpp_lib_constexpr_set}@ 202502L // also in \libheader{set}

#define @\defnlibxname{cpp_lib_constexpr_stack}@ 202502L // also in \libheader{stack}

#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_unordered_map}@ 202502L // also in \libheader{unordered_map}

#define @\defnlibxname{cpp_lib_constexpr_unordered_set}@ 202502L // also in \libheader{unordered_set}

#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}@ 202411L // freestanding,

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

#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_contracts}@ 202502L // freestanding, also in \libheader{contracts}

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

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

#define @\defnlibxname{cpp_lib_counting_scope}@ 202506L // also in \libheader{execution}

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

#define @\defnlibxname{cpp_lib_define_static}@ 202506L // freestanding, also in \libheader{meta}

#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_exception_ptr_cast}@ 202603L // also in \libheader{exception}

#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}@ 202511L // also in \libheader{flat_map}

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

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

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

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

#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}@ 202502L // 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_execution}@ 202502L // freestanding, also in \libheader{execution}

#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}@ 202502L // freestanding, also in \libheader{memory}

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

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

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

#define @\defnlibxname{cpp_lib_freestanding_random}@ 202502L // freestanding, also in \libheader{random}

#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}@ 202604L // freestanding, also in \libheader{functional}

#define @\defnlibxname{cpp_lib_gcd_lcm}@ 201606L // freestanding, 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_hive}@ 202502L // also in \libheader{hive}

#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_indirect}@ 202502L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_initializer_list}@ 202511L

// freestanding, also in \libheader{initializer_list}

#define @\defnlibxname{cpp_lib_inplace_vector}@ 202603L // 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 // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_integer_sequence}@ 202511L // 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 // freestanding, 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_structural}@ 202603L

// freestanding, also in \libheader{meta} and \libheader{type_traits}

#define @\defnlibxname{cpp_lib_is_sufficiently_aligned}@ 202411L // freestanding, also in \libheader{memory}

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

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

#define @\defnlibxname{cpp_lib_is_within_lifetime}@ 202603L // freestanding, 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}@ 202511L // 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 // freestanding, 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_observable_checkpoint}@ 202506L // freestanding, also in \libheader{utility}

#define @\defnlibxname{cpp_lib_optional}@ 202506L // 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}@ 202506L

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

#define @\defnlibxname{cpp_lib_parallel_scheduler}@ 202506L // also in \libheader{execution}

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

#define @\defnlibxname{cpp_lib_polymorphic}@ 202502L // also in \libheader{memory}

#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_input}@ 202502L // freestanding, also in \libheader{ranges}

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

#define @\defnlibxname{cpp_lib_ranges_cache_latest}@ 202411L // 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 // freestanding, also in \libheader{algorithm}

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

#define @\defnlibxname{cpp_lib_ranges_filter}@ 202603L // freestanding, also in \libheader{ranges}

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

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

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

#define @\defnlibxname{cpp_lib_ranges_indices}@ 202506L // also in \libheader{ranges}

#define @\defnlibxname{cpp_lib_ranges_iota}@ 202202L // freestanding, 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_reserve_hint}@ 202502L // 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 // freestanding, 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 // freestanding, also in \libheader{ratio}

#define @\defnlibxname{cpp_lib_raw_memory_algorithms}@ 202411L // 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_reflection}@ 202603L // also in \libheader{meta}

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

#define @\defnlibxname{cpp_lib_replaceable_contract_violation_handler}@ @\seebelow@

// freestanding, also in \libheader{contracts}

#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 // freestanding, also in \libheader{algorithm}

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

#define @\defnlibxname{cpp_lib_saturation_arithmetic}@ 202603L // freestanding, 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}@ 202506L // 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_simd}@ 202603L // also in \libheader{simd}

#define @\defnlibxname{cpp_lib_simd_complex}@ 202502L // also in \libheader{simd}

#define @\defnlibxname{cpp_lib_simd_permutations}@ 202506L // also in \libheader{simd}

#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_spanstream}@ 202106L // also in \libheader{iosfwd}, \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}@ 202603L // freestanding, also in \libheader{memory}

#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_stdbit_h}@ 202603L // also in \libheader{stdbit.h}

#define @\defnlibxname{cpp_lib_stdckdint_h}@ 202603L // also in \libheader{stdckdint.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_subview}@ 202506L // also in \libheader{string}, \libheader{string_view}

#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}@ 202603L // freestanding, also in \libheader{mdspan}

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

#define @\defnlibxname{cpp_lib_task}@ 202506L // also in \libheader{execution}

#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 // freestanding, 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_order}@ 202506L // also in \libheader{compare}

#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_valarray}@ 202511L // also in \libheader{valarray}

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

Additionally, each of the following macros is defined in a hardened implementation:

\begin{codeblock}

#define @\defnlibxname{cpp_lib_hardened_array}@ 202502L // also in \libheader{array}

#define @\defnlibxname{cpp_lib_hardened_basic_stacktrace}@ 202506L // also in \libheader{stacktrace}

#define @\defnlibxname{cpp_lib_hardened_basic_string}@ 202502L // also in \libheader{string}

#define @\defnlibxname{cpp_lib_hardened_basic_string_view}@ 202502L // also in \libheader{string_view}

#define @\defnlibxname{cpp_lib_hardened_bitset}@ 202502L // also in \libheader{bitset}

#define @\defnlibxname{cpp_lib_hardened_common_iterator}@ 202506L // also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_hardened_counted_iterator}@ 202506L // also in \libheader{iterator}

#define @\defnlibxname{cpp_lib_hardened_deque}@ 202502L // also in \libheader{deque}

#define @\defnlibxname{cpp_lib_hardened_expected}@ 202502L // also in \libheader{expected}

#define @\defnlibxname{cpp_lib_hardened_forward_list}@ 202502L // also in \libheader{forward_list}

#define @\defnlibxname{cpp_lib_hardened_inplace_vector}@ 202502L // also in \libheader{inplace_vector}

#define @\defnlibxname{cpp_lib_hardened_list}@ 202502L // also in \libheader{list}

#define @\defnlibxname{cpp_lib_hardened_mdspan}@ 202502L // also in \libheader{mdspan}

#define @\defnlibxname{cpp_lib_hardened_optional}@ 202502L // also in \libheader{optional}

#define @\defnlibxname{cpp_lib_hardened_shared_ptr_array}@ 202506L // also in \libheader{memory}

#define @\defnlibxname{cpp_lib_hardened_span}@ 202502L // also in \libheader{span}

#define @\defnlibxname{cpp_lib_hardened_valarray}@ 202502L // also in \libheader{valarray}

#define @\defnlibxname{cpp_lib_hardened_vector}@ 202502L // also in \libheader{vector}

#define @\defnlibxname{cpp_lib_hardened_view_interface}@ 202506L // also in \libheader{ranges}

\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}.

The macro \xname{cpp_lib_replaceable_contract_violation_handler} is defined to

the integer literal \tcode{202603L}

if the contract-violation handler is replaceable, and

to the integer literal \tcode{0} otherwise\iref{basic.contract.handler}.

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

if the implementation provides the corresponding facility in its entirety.

A non-hardened implementation should not define macros from \libheader{version}

required for hardened implementations.

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