support.tex

%!TEX root = std.tex
\rSec0[language.support]{Language support library}

\rSec1[support.general]{General}

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

\pnum
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{lang.sup.lib.summary}.

\begin{libsumtab}{Language support library summary}{tab:lang.sup.lib.summary}
\ref{support.types}       & Common definitions        &   \tcode{<cstddef>}   \\
                          &                           &   \tcode{<cstdlib>}   \\ \rowsep
\ref{support.limits}      & Implementation properties &   \tcode{<limits>}    \\
                          &                           &   \tcode{<climits>}   \\
                          &                           &   \tcode{<cfloat>}    \\
                          &                           &   \tcode{<version>}   \\ \rowsep
\ref{cstdint}             & Integer types             &   \tcode{<cstdint>}   \\ \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>}  \\ \rowsep
\ref{support.contract}    & Contract violation handling & \tcode{<contract>}  \\ \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{<csignal>}   \\
                          &                           &   \tcode{<csetjmp>}   \\
                          &                           &   \tcode{<cstdarg>}   \\
                          &                           &   \tcode{<cstdlib>}   \\
\end{libsumtab}

\rSec1[support.types]{Common definitions}

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

\indexlibrary{\idxcode{NULL}}%
\indexlibrary{\idxcode{offsetof}}%
\indexlibrary{\idxcode{ptrdiff_t}}%
\indexlibrary{\idxcode{size_t}}%
\indexlibrary{\idxcode{max_align_t}}%
\indexlibrary{\idxcode{nullptr_t}}%
\indexlibrary{\idxcode{byte}}%
\begin{codeblock}
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}

\pnum
The contents and meaning of the header \tcode{<cstddef>} are the same as
the C standard library header \tcode{<stddef.h>},
except that it does not declare the type \tcode{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}

\indexhdr{cstdlib}%
\indexlibrary{\idxcode{EXIT_FAILURE}}%
\indexlibrary{\idxcode{EXIT_SUCCESS}}%
\indexlibrary{\idxcode{MB_CUR_MAX}}%
\indexlibrary{\idxcode{NULL}}%
\indexlibrary{\idxcode{RAND_MAX}}%
\indexlibrary{\idxcode{_Exit}}%
\indexlibrary{\idxcode{abort}}%
\indexlibrary{\idxcode{abs}}%
\indexlibrary{\idxcode{aligned_alloc}}%
\indexlibrary{\idxcode{at_quick_exit}}%
\indexlibrary{\idxcode{atexit}}%
\indexlibrary{\idxcode{atof}}%
\indexlibrary{\idxcode{atoi}}%
\indexlibrary{\idxcode{atol}}%
\indexlibrary{\idxcode{atoll}}%
\indexlibrary{\idxcode{bsearch}}%
\indexlibrary{\idxcode{calloc}}%
\indexlibrary{\idxcode{div}}%
\indexlibrary{\idxcode{div_t}}%
\indexlibrary{\idxcode{exit}}%
\indexlibrary{\idxcode{free}}%
\indexlibrary{\idxcode{getenv}}%
\indexlibrary{\idxcode{labs}}%
\indexlibrary{\idxcode{ldiv}}%
\indexlibrary{\idxcode{ldiv_t}}%
\indexlibrary{\idxcode{llabs}}%
\indexlibrary{\idxcode{lldiv}}%
\indexlibrary{\idxcode{lldiv_t}}%
\indexlibrary{\idxcode{malloc}}%
\indexlibrary{\idxcode{mblen}}%
\indexlibrary{\idxcode{mbstowcs}}%
\indexlibrary{\idxcode{mbtowc}}%
\indexlibrary{\idxcode{qsort}}%
\indexlibrary{\idxcode{quick_exit}}%
\indexlibrary{\idxcode{rand}}%
\indexlibrary{\idxcode{realloc}}%
\indexlibrary{\idxcode{size_t}}%
\indexlibrary{\idxcode{srand}}%
\indexlibrary{\idxcode{strtod}}%
\indexlibrary{\idxcode{strtof}}%
\indexlibrary{\idxcode{strtol}}%
\indexlibrary{\idxcode{strtold}}%
\indexlibrary{\idxcode{strtoll}}%
\indexlibrary{\idxcode{strtoul}}%
\indexlibrary{\idxcode{strtoull}}%
\indexlibrary{\idxcode{system}}%
\indexlibrary{\idxcode{wcstombs}}%
\indexlibrary{\idxcode{wctomb}}%
\begin{codeblock}
namespace std {
  using size_t = @\seebelow@;
  using div_t = @\seebelow@;
  using ldiv_t = @\seebelow@;
  using lldiv_t = @\seebelow@;
}

#define NULL @\seebelow@
#define EXIT_FAILURE @\seebelow@
#define EXIT_SUCCESS @\seebelow@
#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;
  int atexit(@\placeholder{c-atexit-handler}@* func) noexcept;
  int atexit(@\placeholder{atexit-handler}@* func) noexcept;
  int at_quick_exit(@\placeholder{c-atexit-handler}@* func) noexcept;
  int at_quick_exit(@\placeholder{atexit-handler}@* func) noexcept;
  [[noreturn]] void exit(int status);
  [[noreturn]] void _Exit(int status) noexcept;
  [[noreturn]] void quick_exit(int status) noexcept;

  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,
                @\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar);
  void* bsearch(const void* key, const void* base, size_t nmemb, 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);
  void qsort(void* base, size_t nmemb, size_t size, @\placeholder{compare-pred}@*@\itcorr[-1]@ compar);

  // \ref{c.math.rand}, low-quality random number generation
  int rand();
  void srand(unsigned int seed);

  // \ref{c.math.abs}, absolute values
  int abs(int j);
  long int abs(long int j);
  long long int abs(long long int j);
  float abs(float j);
  double abs(double j);
  long double abs(long double j);

  long int labs(long int j);
  long long int llabs(long long int j);

  div_t div(int numer, int denom);
  ldiv_t div(long int numer, long int denom);             // see \ref{library.c}
  lldiv_t div(long long int numer, long long int denom);  // see \ref{library.c}
  ldiv_t ldiv(long int numer, long int denom);
  lldiv_t lldiv(long long int numer, long long int denom);
}
\end{codeblock}

\pnum
The contents and meaning of the header \tcode{<cstdlib>} are the same as
the C standard library header \tcode{<stdlib.h>},
except that it does not declare the type \tcode{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}

\pnum
\indexlibrary{\idxcode{nullptr_t}}%
The type \tcode{nullptr_t} is a synonym
for the type of a \tcode{nullptr} expression, and it
has the characteristics
described in~\ref{basic.fundamental} and~\ref{conv.ptr}.
\begin{note}
Although \tcode{nullptr}'s address cannot be taken, the address of another
\tcode{nullptr_t} object that is an lvalue can be taken.
\end{note}

\pnum
The macro
\indexlibrary{\idxcode{NULL}}%
\tcode{NULL}
is an \impldef{definition of \tcode{NULL}} null pointer constant.%
\footnote{Possible definitions include
\tcode{0}
and
\tcode{0L},
but not
\tcode{(void*)0}.}

\xrefc{7.19}

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

\pnum
The macro
\indexlibrary{\idxcode{offsetof}}%
\tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}
has the same semantics as the corresponding macro in
the C standard library header \tcode{<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.\footnote{Note that \tcode{offsetof}
is required to work as specified even if unary
\tcode{operator\&}
is overloaded for any of the types involved.}
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}.

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

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

\pnum
\begin{note}
It is recommended that implementations 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.
\end{note}

\pnum
The type
\indexlibrary{\idxcode{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}
\pnum \constraints \tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects 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}
\pnum \constraints \tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:
\begin{codeblock}
return static_cast<byte>(static_cast<unsigned char>(
	                   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}
\pnum \constraints \tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:
\tcode{return b >> shift;}
\end{itemdescr}

\indexlibrarymember{operator>>}{byte}%
\begin{itemdecl}
template<class IntType>
  constexpr byte operator>>(byte b, IntType shift) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \constraints \tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:
\begin{codeblock}
return static_cast<byte>(static_cast<unsigned char>(
	                   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}
\pnum \effects 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}
\pnum \effects Equivalent to:
\begin{codeblock}
return static_cast<byte>(static_cast<unsigned char>(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}
\pnum \effects 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}
\pnum \effects Equivalent to:
\begin{codeblock}
return static_cast<byte>(static_cast<unsigned char>(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}
\pnum \effects 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}
\pnum \effects Equivalent to:
\begin{codeblock}
return static_cast<byte>(static_cast<unsigned char>(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}
\pnum \effects Equivalent to:
\begin{codeblock}
return static_cast<byte>(static_cast<unsigned char>(
	                   ~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}
\pnum \constraints \tcode{is_integral_v<IntType>} is \tcode{true}.

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

\rSec1[support.limits]{Implementation properties}

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

\pnum
The headers
\tcode{<limits>}\iref{limits.syn},
\tcode{<climits>}\iref{climits.syn}, and
\tcode{<cfloat>}\iref{cfloat.syn}
supply characteristics of
\indextext{implementation-dependent}%
imple\-mentation-dependent
arithmetic types\iref{basic.fundamental}.

\pnum
The header \tcode{<version>}
supplies implementation-dependent information
about the C++ standard library
(e.g., version number and release date).

\pnum
The macros in \tref{support.ft} are defined
after inclusion of the header \tcode{<version>} or
one of the corresponding headers specified in the table.
\begin{note}
Future versions of this International Standard might replace
the values of these macros with greater values.
\end{note}

\begin{LongTable}{Standard library feature-test macros}
{tab:support.ft}{llx{.3\hsize}}
\\ \topline
\lhdr{Macro name} & \chdr{Value} & \rhdr{Header(s)} \\ \capsep
\endfirsthead
\continuedcaption \\
\hline
\lhdr{Macro name} & \chdr{Value} & \rhdr{Header(s)} \\ \capsep
\endhead
\defnlibxname{cpp_lib_addressof_constexpr}                  & \tcode{201603L} &
  \tcode{<memory>} \\ \rowsep
\defnlibxname{cpp_lib_allocator_traits_is_always_equal}     & \tcode{201411L} &
  \tcode{<memory>} \tcode{<scoped_allocator>} \tcode{<string>}
  \tcode{<deque>} \tcode{<forward_list>} \tcode{<list>} \tcode{<vector>}
  \tcode{<map>} \tcode{<set>} \tcode{<unordered_map>}
  \tcode{<unordered_set>} \\ \rowsep
\defnlibxname{cpp_lib_any}                                  & \tcode{201606L} &
  \tcode{<any>} \\ \rowsep
\defnlibxname{cpp_lib_apply}                                & \tcode{201603L} &
  \tcode{<tuple>} \\ \rowsep
\defnlibxname{cpp_lib_array_constexpr}                      & \tcode{201603L} &
  \tcode{<iterator>} \tcode{<array>} \\ \rowsep
\defnlibxname{cpp_lib_as_const}                             & \tcode{201510L} &
  \tcode{<utility>} \\ \rowsep
\defnlibxname{cpp_lib_atomic_is_always_lock_free}           & \tcode{201603L} &
  \tcode{<atomic>} \\ \rowsep
\defnlibxname{cpp_lib_atomic_ref}                           & \tcode{201806L} &
  \tcode{<atomic>} \\ \rowsep
\defnlibxname{cpp_lib_bit_cast}                             & \tcode{201806L} &
  \tcode{<bit>} \\ \rowsep
\defnlibxname{cpp_lib_bind_front}                           & \tcode{201811L} &
  \tcode{<functional>} \\ \rowsep
\defnlibxname{cpp_lib_bool_constant}                        & \tcode{201505L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_bounded_array_traits}                 & \tcode{201902L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_boyer_moore_searcher}                 & \tcode{201603L} &
  \tcode{<functional>} \\ \rowsep
\defnlibxname{cpp_lib_byte}                                 & \tcode{201603L} &
  \tcode{<cstddef>} \\ \rowsep
\defnlibxname{cpp_lib_char8_t}                              & \tcode{201811L} &
  \tcode{<atomic>} \tcode{<filesystem>} \tcode{<istream>} \tcode{<limits>}
  \tcode{<locale>} \tcode{<ostream>} \tcode{<string>} \tcode{<string_view>}
  \\ \rowsep
\defnlibxname{cpp_lib_chrono}                               & \tcode{201611L} &
  \tcode{<chrono>} \\ \rowsep
\defnlibxname{cpp_lib_chrono_udls}                          & \tcode{201304L} &
  \tcode{<chrono>} \\ \rowsep
\defnlibxname{cpp_lib_clamp}                                & \tcode{201603L} &
  \tcode{<algorithm>} \\ \rowsep
\defnlibxname{cpp_lib_complex_udls}                         & \tcode{201309L} &
  \tcode{<complex>} \\ \rowsep
\defnlibxname{cpp_lib_concepts}                             & \tcode{201806L} &
  \tcode{<concepts>} \\ \rowsep
\defnlibxname{cpp_lib_constexpr_misc}                       & \tcode{201811L} &
  \tcode{<array>} \tcode{<functional>} \tcode{<iterator>}
  \tcode{<string_view>} \tcode{<tuple>} \tcode{<utility>} \\ \rowsep
\defnlibxname{cpp_lib_constexpr_swap_algorithms}            & \tcode{201806L} &
  \tcode{<algorithm>} \\ \rowsep
\defnlibxname{cpp_lib_destroying_delete}                    & \tcode{201806L} &
  \tcode{<new>} \\ \rowsep
\defnlibxname{cpp_lib_enable_shared_from_this}              & \tcode{201603L} &
  \tcode{<memory>} \\ \rowsep
\defnlibxname{cpp_lib_erase_if}                             & \tcode{201811L} &
  \tcode{<string>} \tcode{<deque>} \tcode{<forward_list>} \tcode{<list>}
  \tcode{<vector>} \tcode{<map>} \tcode{<set>} \tcode{<unordered_map>}
  \tcode{<unordered_set>} \\ \rowsep
\defnlibxname{cpp_lib_exchange_function}                    & \tcode{201304L} &
  \tcode{<utility>} \\ \rowsep
\defnlibxname{cpp_lib_execution}                            & \tcode{201902L} &
  \tcode{<execution>} \\ \rowsep
\defnlibxname{cpp_lib_filesystem}                           & \tcode{201703L} &
  \tcode{<filesystem>} \\ \rowsep
\defnlibxname{cpp_lib_gcd_lcm}                              & \tcode{201606L} &
  \tcode{<numeric>} \\ \rowsep
\defnlibxname{cpp_lib_generic_associative_lookup}           & \tcode{201304L} &
  \tcode{<map>} \tcode{<set>} \\ \rowsep
\defnlibxname{cpp_lib_generic_unordered_lookup}             & \tcode{201811L} &
  \tcode{<unordered_map>} \tcode{<unordered_set>} \\ \rowsep
\defnlibxname{cpp_lib_generic_unordered_hash_lookup}        & \tcode{201902L} &
  \tcode{<unordered_map>} \tcode{<unordered_set>} \\ \rowsep
\defnlibxname{cpp_lib_hardware_interference_size}           & \tcode{201703L} &
  \tcode{<new>} \\ \rowsep
\defnlibxname{cpp_lib_has_unique_object_representations}    & \tcode{201606L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_hypot}                                & \tcode{201603L} &
  \tcode{<cmath>} \\ \rowsep
\defnlibxname{cpp_lib_incomplete_container_elements}        & \tcode{201505L} &
  \tcode{<forward_list>} \tcode{<list>} \tcode{<vector>} \\ \rowsep
\defnlibxname{cpp_lib_integer_sequence}                     & \tcode{201304L} &
  \tcode{<utility>} \\ \rowsep
\defnlibxname{cpp_lib_integral_constant_callable}           & \tcode{201304L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_interpolate}                          & \tcode{201902L} &
  \tcode{<cmath>} \tcode{<numeric>} \\ \rowsep
\defnlibxname{cpp_lib_invoke}                               & \tcode{201411L} &
  \tcode{<functional>} \\ \rowsep
\defnlibxname{cpp_lib_is_aggregate}                         & \tcode{201703L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_is_constant_evaluated}                & \tcode{201811L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_is_final}                             & \tcode{201402L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_is_invocable}                         & \tcode{201703L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_is_null_pointer}                      & \tcode{201309L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_is_swappable}                         & \tcode{201603L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_launder}                              & \tcode{201606L} &
  \tcode{<new>} \\ \rowsep
\defnlibxname{cpp_lib_list_remove_return_type}              & \tcode{201806L} &
  \tcode{<forward_list>} \tcode{<list>} \\ \rowsep
\defnlibxname{cpp_lib_logical_traits}                       & \tcode{201510L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_make_from_tuple}                      & \tcode{201606L} &
  \tcode{<tuple>} \\ \rowsep
\defnlibxname{cpp_lib_make_reverse_iterator}                & \tcode{201402L} &
  \tcode{<iterator>} \\ \rowsep
\defnlibxname{cpp_lib_make_unique}                          & \tcode{201304L} &
  \tcode{<memory>} \\ \rowsep
\defnlibxname{cpp_lib_map_try_emplace}                      & \tcode{201411L} &
  \tcode{<map>} \\ \rowsep
\defnlibxname{cpp_lib_math_special_functions}               & \tcode{201603L} &
  \tcode{<cmath>} \\ \rowsep
\defnlibxname{cpp_lib_memory_resource}                      & \tcode{201603L} &
  \tcode{<memory_resource>} \\ \rowsep
\defnlibxname{cpp_lib_node_extract}                         & \tcode{201606L} &
  \tcode{<map>} \tcode{<set>} \tcode{<unordered_map>}
  \tcode{<unordered_set>} \\ \rowsep
\defnlibxname{cpp_lib_nonmember_container_access}           & \tcode{201411L} &
  \tcode{<iterator>} \tcode{<array>} \tcode{<deque>} \tcode{<forward_list>}
  \tcode{<list>} \tcode{<map>} \tcode{<regex>} \tcode{<set>} \tcode{<string>}
  \tcode{<unordered_map>} \tcode{<unordered_set>} \tcode{<vector>} \\ \rowsep
\defnlibxname{cpp_lib_not_fn}                               & \tcode{201603L} &
  \tcode{<functional>} \\ \rowsep
\defnlibxname{cpp_lib_null_iterators}                       & \tcode{201304L} &
  \tcode{<iterator>} \\ \rowsep
\defnlibxname{cpp_lib_optional}                             & \tcode{201606L} &
  \tcode{<optional>} \\ \rowsep
\defnlibxname{cpp_lib_parallel_algorithm}                   & \tcode{201603L} &
  \tcode{<algorithm>} \tcode{<numeric>} \\ \rowsep
\defnlibxname{cpp_lib_quoted_string_io}                     & \tcode{201304L} &
  \tcode{<iomanip>} \\ \rowsep
\defnlibxname{cpp_lib_ranges}                               & \tcode{201811L} &
  \tcode{<algorithm>} \tcode{<functional>} \tcode{<iterator>}
  \tcode{<memory>} \tcode{<ranges>} \\ \rowsep
\defnlibxname{cpp_lib_raw_memory_algorithms}                & \tcode{201606L} &
  \tcode{<memory>} \\ \rowsep
\defnlibxname{cpp_lib_result_of_sfinae}                     & \tcode{201210L} &
  \tcode{<functional>} \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_robust_nonmodifying_seq_ops}          & \tcode{201304L} &
  \tcode{<algorithm>} \\ \rowsep
\defnlibxname{cpp_lib_sample}                               & \tcode{201603L} &
  \tcode{<algorithm>} \\ \rowsep
\defnlibxname{cpp_lib_scoped_lock}                          & \tcode{201703L} &
  \tcode{<mutex>} \\ \rowsep
\defnlibxname{cpp_lib_shared_mutex}                         & \tcode{201505L} &
  \tcode{<shared_mutex>} \\ \rowsep
\defnlibxname{cpp_lib_shared_ptr_arrays}                    & \tcode{201611L} &
  \tcode{<memory>} \\ \rowsep
\defnlibxname{cpp_lib_shared_ptr_weak_type}                 & \tcode{201606L} &
  \tcode{<memory>} \\ \rowsep
\defnlibxname{cpp_lib_shared_timed_mutex}                   & \tcode{201402L} &
  \tcode{<shared_mutex>} \\ \rowsep
\defnlibxname{cpp_lib_string_udls}                          & \tcode{201304L} &
  \tcode{<string>} \\ \rowsep
\defnlibxname{cpp_lib_string_view}                          & \tcode{201606L} &
  \tcode{<string>} \tcode{<string_view>} \\ \rowsep
\defnlibxname{cpp_lib_three_way_comparison}                 & \tcode{201711L} &
  \tcode{<compare>} \\ \rowsep
\defnlibxname{cpp_lib_to_chars}                             & \tcode{201611L} &
  \tcode{<charconv>} \\ \rowsep
\defnlibxname{cpp_lib_transformation_trait_aliases}         & \tcode{201304L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_transparent_operators}                & \tcode{201510L} &
  \tcode{<memory>} \tcode{<functional>} \\ \rowsep
\defnlibxname{cpp_lib_tuple_element_t}                      & \tcode{201402L} &
  \tcode{<tuple>} \\ \rowsep
\defnlibxname{cpp_lib_tuples_by_type}                       & \tcode{201304L} &
  \tcode{<utility>} \tcode{<tuple>} \\ \rowsep
\defnlibxname{cpp_lib_type_trait_variable_templates}        & \tcode{201510L} &
  \tcode{<type_traits>} \\ \rowsep
\defnlibxname{cpp_lib_uncaught_exceptions}                  & \tcode{201411L} &
  \tcode{<exception>} \\ \rowsep
\defnlibxname{cpp_lib_unordered_map_try_emplace}            & \tcode{201411L} &
  \tcode{<unordered_map>} \\ \rowsep
\defnlibxname{cpp_lib_variant}                              & \tcode{201606L} &
  \tcode{<variant>} \\ \rowsep
\defnlibxname{cpp_lib_void_t}                               & \tcode{201411L} &
  \tcode{<type_traits>} \\ \rowsep
\end{LongTable}

\rSec2[limits.syn]{Header \tcode{<limits>} synopsis}
\indexhdr{limits}%
\indextext{\idxcode{numeric_limits}}%
\indexlibrary{\idxcode{numeric_limits}}%
\indexlibrary{\idxcode{float_round_style}}%
\indexlibrary{\idxcode{float_denorm_style}}%

\begin{codeblock}
namespace std {
  // \ref{fp.style}, floating-point type properties
  enum float_round_style;
  enum float_denorm_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[fp.style]{Floating-point type properties}

\rSec3[round.style]{Type \tcode{float_round_style}}

\indexlibrary{\idxcode{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}

\pnum
The rounding mode for floating-point arithmetic is characterized by the
values:

\begin{itemize}
\item
\indexlibrary{\idxcode{round_indeterminate}}%
\tcode{round_indeterminate}
if the rounding style is indeterminable
\item
\indexlibrary{\idxcode{round_toward_zero}}%
\tcode{round_toward_zero}
if the rounding style is toward zero
\item
\indexlibrary{\idxcode{round_to_nearest}}%
\tcode{round_to_nearest}
if the rounding style is to the nearest representable value
\item
\indexlibrary{\idxcode{round_toward_infinity}}%
\tcode{round_toward_infinity}
if the rounding style is toward infinity
\item
\indexlibrary{\idxcode{round_toward_neg_infinity}}%
\tcode{round_toward_neg_infinity}
if the rounding style is toward negative infinity
\end{itemize}

\rSec3[denorm.style]{Type \tcode{float_denorm_style}}

\indexlibrary{\idxcode{float_denorm_style}}%
\begin{codeblock}
namespace std {
  enum float_denorm_style {
    denorm_indeterminate = -1,
    denorm_absent = 0,
    denorm_present = 1
  };
}
\end{codeblock}

\indextext{denormalized value|see{number, subnormal}}%
\indextext{value!denormalized|see{number, subnormal}}%
\indextext{subnormal number|see{number, subnormal}}%
\indextext{number!subnormal}%
\pnum
The presence or absence of subnormal numbers (variable number of exponent bits)
is characterized by the values:

\begin{itemize}
\item
\indexlibrary{\idxcode{denorm_indeterminate}}%
\tcode{denorm_indeterminate}
if it cannot be determined whether or not the type allows subnormal values
\item
\indexlibrary{\idxcode{denorm_absent}}%
\tcode{denorm_absent}
if the type does not allow subnormal values
\item
\indexlibrary{\idxcode{denorm_present}}%
\tcode{denorm_present}
if the type does allow subnormal values
\end{itemize}

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

\pnum
The
\indexlibrary{\idxcode{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.

\indexlibrary{\idxcode{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 float_denorm_style has_denorm = denorm_absent;
    static constexpr bool has_denorm_loss = false;
    static constexpr T infinity() noexcept { return T(); }
    static constexpr T quiet_NaN() noexcept { return T(); }
    static constexpr T signaling_NaN() noexcept { return T(); }
    static constexpr T denorm_min() noexcept { return T(); }

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

    static constexpr bool traps = false;
    static constexpr bool tinyness_before = false;
    static constexpr float_round_style round_style = round_toward_zero;
  };
}
\end{codeblock}

\pnum
For all members declared
\tcode{static} \tcode{constexpr}
in the
\tcode{numeric_limits}
template, specializations shall define these values in such a way
that they are usable as
constant expressions.

\pnum
The default
\tcode{numeric_limits<T>}
template shall have all members, but with 0 or
\tcode{false}
values.

\pnum
Specializations shall be provided for each
arithmetic type,
both floating-point and integer, including
\tcode{bool}.
The member
\tcode{is_specialized}
shall be
\tcode{true}
for all such specializations of
\tcode{numeric_limits}.

\pnum
The value of each member of a specialization of
\tcode{numeric_limits} on a cv-qualified type
\tcode{cv T} shall be equal to the value of the corresponding member of
the specialization on the unqualified type \tcode{T}.

\pnum
Non-arithmetic standard types, such as
\tcode{complex<T>}\iref{complex}, shall not have specializations.

\rSec3[numeric.limits.members]{\tcode{numeric_limits} members}

\pnum
\indextext{signal-safe!\idxcode{numeric_limits} members}%
Each member function defined in this subclause is signal-safe\iref{support.signal}.

\indexlibrarymember{min}{numeric_limits}%
\begin{itemdecl}
static constexpr T min() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Minimum finite value.\footnote{Equivalent to \tcode{CHAR_MIN}, \tcode{SHRT_MIN},
\tcode{FLT_MIN}, \tcode{DBL_MIN}, etc.}

\indextext{number!subnormal}%
\pnum
For floating-point types with subnormal numbers, returns the minimum positive
normalized value.

\pnum
Meaningful for all specializations in which
\tcode{is_bounded != false},
or
\tcode{is_bounded == false \&\& is_signed == false}.
\end{itemdescr}

\indexlibrarymember{max}{numeric_limits}%
\begin{itemdecl}
static constexpr T max() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Maximum finite value.\footnote{Equivalent to \tcode{CHAR_MAX}, \tcode{SHRT_MAX},
\tcode{FLT_MAX}, \tcode{DBL_MAX}, etc.}

\pnum
Meaningful for all specializations in which
\tcode{is_bounded != false}.
\end{itemdescr}

\indexlibrarymember{lowest}{numeric_limits}%
\begin{itemdecl}
static constexpr T lowest() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
A finite value \tcode{x} such that there is no other finite
value \tcode{y} where \tcode{y < x}.\footnote{\tcode{lowest()} is necessary because not all
floating-point representations have a smallest (most negative) value that is
the negative of the largest (most positive) finite value.}

\pnum
Meaningful for all specializations in which \tcode{is_bounded != false}.
\end{itemdescr}

\indexlibrarymember{digits}{numeric_limits}%
\begin{itemdecl}
static constexpr int digits;
\end{itemdecl}

\begin{itemdescr}
\pnum
Number of
\tcode{radix}
digits that can be represented without change.

\pnum
For integer types, the number of non-sign bits in the representation.

\pnum For floating-point types, the number of \tcode{radix} digits in the
mantissa.\footnote{Equivalent to \tcode{FLT_MANT_DIG}, \tcode{DBL_MANT_DIG},
\tcode{LDBL_MANT_DIG}.} \end{itemdescr}

\indexlibrarymember{digits10}{numeric_limits}%
\begin{itemdecl}
static constexpr int digits10;
\end{itemdecl}

\begin{itemdescr}
\pnum
Number of base 10 digits that can be represented without
change.\footnote{Equivalent to \tcode{FLT_DIG}, \tcode{DBL_DIG},
\tcode{LDBL_DIG}.}

\pnum
Meaningful for all specializations in which
\tcode{is_bounded != false}.
\end{itemdescr}

\indexlibrarymember{max_digits10}{numeric_limits}%
\begin{itemdecl}
static constexpr int max_digits10;
\end{itemdecl}

\begin{itemdescr}
\pnum
Number of base 10 digits required to ensure that values which
differ are always differentiated.

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{is_signed}{numeric_limits}%
\begin{itemdecl}
static constexpr bool is_signed;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type is signed.

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{is_integer}{numeric_limits}%
\begin{itemdecl}
static constexpr bool is_integer;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type is integer.

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{is_exact}{numeric_limits}%
\begin{itemdecl}
static constexpr bool is_exact;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type uses an exact representation.
All integer types are exact, but not all exact types are integer.
For example, rational and fixed-exponent representations are exact but not integer.

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{radix}{numeric_limits}%
\begin{itemdecl}
static constexpr int radix;
\end{itemdecl}

\begin{itemdescr}
\pnum
For floating-point types, specifies the base or radix of the exponent representation
(often 2).\footnote{Equivalent to \tcode{FLT_RADIX}.}

\pnum
For integer types, specifies the base of the
representation.\footnote{Distinguishes types with bases other than 2 (e.g.
BCD).}

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{epsilon}{numeric_limits}%
\begin{itemdecl}
static constexpr T epsilon() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Machine epsilon:  the difference between 1 and the least value greater than 1
that is representable.\footnote{Equivalent to \tcode{FLT_EPSILON}, \tcode{DBL_EPSILON}, \tcode{LDBL_EPSILON}.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{round_error}{numeric_limits}%
\begin{itemdecl}
static constexpr T round_error() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Measure of the maximum rounding error.\footnote{Rounding error is described in
LIA-1
Section 5.2.4 and
Annex C Rationale Section C.5.2.4 --- Rounding and rounding constants.}
\end{itemdescr}

\indexlibrarymember{min_exponent}{numeric_limits}%
\begin{itemdecl}
static constexpr int  min_exponent;
\end{itemdecl}

\begin{itemdescr}
\pnum
Minimum negative integer such that
\tcode{radix}
raised to the power of one less than that integer is a normalized floating-point
number.\footnote{Equivalent to \tcode{FLT_MIN_EXP}, \tcode{DBL_MIN_EXP},
\tcode{LDBL_MIN_EXP}.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{min_exponent10}{numeric_limits}%
\begin{itemdecl}
static constexpr int  min_exponent10;
\end{itemdecl}

\begin{itemdescr}
\pnum
Minimum negative integer such that 10 raised to that power is in the range
of normalized floating-point numbers.\footnote{Equivalent to
\tcode{FLT_MIN_10_EXP}, \tcode{DBL_MIN_10_EXP}, \tcode{LDBL_MIN_10_EXP}.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{max_exponent}{numeric_limits}%
\begin{itemdecl}
static constexpr int  max_exponent;
\end{itemdecl}

\begin{itemdescr}
\pnum
Maximum positive integer such that
\tcode{radix}
raised to the power one less than that integer is a representable finite
floating-point number.\footnote{Equivalent to \tcode{FLT_MAX_EXP},
\tcode{DBL_MAX_EXP}, \tcode{LDBL_MAX_EXP}.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{max_exponent10}{numeric_limits}%
\begin{itemdecl}
static constexpr int  max_exponent10;
\end{itemdecl}

\begin{itemdescr}
\pnum
Maximum positive integer such that 10 raised to that power is in the
range of representable finite floating-point numbers.\footnote{Equivalent to
\tcode{FLT_MAX_10_EXP}, \tcode{DBL_MAX_10_EXP}, \tcode{LDBL_MAX_10_EXP}.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{has_infinity}{numeric_limits}%
\begin{itemdecl}
static constexpr bool has_infinity;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type has a representation for positive infinity.

\pnum
Meaningful for all floating-point types.

\pnum
Shall be
\tcode{true}
for all specializations in which
\tcode{is_iec559 != false}.
\end{itemdescr}

\indexlibrarymember{has_quiet_NaN}{numeric_limits}%
\begin{itemdecl}
static constexpr bool has_quiet_NaN;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type has a representation for a quiet (non-signaling) ``Not a
Number''.\footnote{Required by LIA-1.}

\pnum
Meaningful for all floating-point types.

\pnum
Shall be
\tcode{true}
for all specializations in which
\tcode{is_iec559 != false}.
\end{itemdescr}

\indexlibrarymember{has_signaling_NaN}{numeric_limits}%
\begin{itemdecl}
static constexpr bool has_signaling_NaN;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type has a representation for a signaling ``Not a Number''.\footnote{Required by LIA-1.}

\pnum
Meaningful for all floating-point types.

\pnum
Shall be
\tcode{true}
for all specializations in which
\tcode{is_iec559 != false}.
\end{itemdescr}

\indexlibrarymember{float_denorm_style}{numeric_limits}%
\begin{itemdecl}
static constexpr float_denorm_style has_denorm;
\end{itemdecl}

\indextext{number!subnormal}%
\begin{itemdescr}
\pnum
\tcode{denorm_present}
if the type allows subnormal values
(variable number of exponent bits)\footnote{Required by LIA-1.},
\tcode{denorm_absent}
if the type does not allow subnormal values,
and
\tcode{denorm_indeterminate}
if it is indeterminate at compile time whether the type allows
subnormal values.

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{has_denorm_loss}{numeric_limits}%
\begin{itemdecl}
static constexpr bool has_denorm_loss;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if loss of accuracy is detected as a
denormalization loss, rather than as an inexact result.\footnote{See
ISO/IEC/IEEE 60559.}
\end{itemdescr}

\indexlibrarymember{infinity}{numeric_limits}%
\begin{itemdecl}
static constexpr T infinity() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Representation of positive infinity, if available.\footnote{Required by LIA-1.}

\pnum
Meaningful for all specializations for which
\tcode{has_infinity != false}.
Required in specializations for which
\tcode{is_iec559 != false}.
\end{itemdescr}

\indexlibrarymember{quiet_NaN}{numeric_limits}%
\begin{itemdecl}
static constexpr T quiet_NaN() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Representation of a quiet ``Not a Number'', if available.\footnote{Required by LIA-1.}

\pnum
Meaningful for all specializations for which
\tcode{has_quiet_NaN != false}.
Required in specializations for which
\tcode{is_iec559 != false}.
\end{itemdescr}

\indexlibrarymember{signaling_NaN}{numeric_limits}%
\begin{itemdecl}
static constexpr T signaling_NaN() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
Representation of a signaling ``Not a Number'', if available.\footnote{Required by LIA-1.}

\pnum
Meaningful for all specializations for which
\tcode{has_signaling_NaN != false}.
Required in specializations for which
\tcode{is_iec559 != false}.
\end{itemdescr}

\indexlibrarymember{denorm_min}{numeric_limits}%
\begin{itemdecl}
static constexpr T denorm_min() noexcept;
\end{itemdecl}

\begin{itemdescr}
\indextext{number!subnormal}%
\pnum
Minimum positive subnormal value.\footnote{Required by LIA-1.}

\pnum
Meaningful for all floating-point types.

\pnum
In specializations for which
\tcode{has_denorm == false},
returns the minimum positive normalized value.
\end{itemdescr}

\indexlibrarymember{is_iec559}{numeric_limits}%
\begin{itemdecl}
static constexpr bool is_iec559;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if and only if the type adheres to ISO/IEC/IEEE
60559.\footnote{ISO/IEC/IEEE 60559:2011 is the same as IEEE 754-2008.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{is_bounded}{numeric_limits}%
\begin{itemdecl}
static constexpr bool is_bounded;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the set of values representable by the type is finite.\footnote{Required by LIA-1.}
\begin{note} All fundamental types\iref{basic.fundamental} are bounded. This member would be \tcode{false} for arbitrary
precision types.\end{note}

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{is_modulo}{numeric_limits}%
\begin{itemdecl}
static constexpr bool is_modulo;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true} if the type is modulo.\footnote{Required by LIA-1.}
A type is modulo if, for any operation involving \tcode{+}, \tcode{-}, or
\tcode{*} on values of that type whose result would fall outside the range
\crange{min()}{max()}, the value returned differs from the true value by an
integer multiple of \tcode{max() - min() + 1}.

\pnum
\begin{example}
\tcode{is_modulo} is \tcode{false} for signed integer types\iref{basic.fundamental}
unless an implementation, as an extension to this document,
defines signed integer overflow to wrap.
\end{example}

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{traps}{numeric_limits}%
\begin{itemdecl}
static constexpr bool traps;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true}
if, at program startup, there exists a value of the type that would cause
an arithmetic operation using that value to trap.\footnote{Required by LIA-1.}

\pnum
Meaningful for all specializations.
\end{itemdescr}

\indexlibrarymember{tinyness_before}{numeric_limits}%
\begin{itemdecl}
static constexpr bool tinyness_before;
\end{itemdecl}

\begin{itemdescr}
\pnum
\tcode{true}
if tinyness is detected before rounding.\footnote{Refer to
ISO/IEC/IEEE 60559.
Required by LIA-1.}

\pnum
Meaningful for all floating-point types.
\end{itemdescr}

\indexlibrarymember{round_style}{numeric_limits}%
\begin{itemdecl}
static constexpr float_round_style round_style;
\end{itemdecl}

\begin{itemdescr}
\pnum
The rounding style for the type.\footnote{Equivalent to \tcode{FLT_ROUNDS}.
Required by LIA-1.}

\pnum
Meaningful for all floating-point types.
Specializations for integer types shall return
\tcode{round_toward_zero}.
\end{itemdescr}

\rSec3[numeric.special]{\tcode{numeric_limits} specializations}

\pnum
All members shall be provided for all specializations.
However, many values are only required to be meaningful under certain
conditions
(for example,
\tcode{epsilon()}
is only meaningful if
\tcode{is_integer}
is
\tcode{false}).
Any value that is not ``meaningful'' shall be set to 0 or
\tcode{false}.

\pnum
\begin{example}
\begin{codeblock}
namespace std {
  template<> class numeric_limits<float> {
  public:
    static constexpr bool is_specialized = true;

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

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

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

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

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

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

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

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

    static constexpr float_round_style round_style = round_to_nearest;
  };
}
\end{codeblock}
\end{example}

\pnum
The specialization for
\tcode{bool}
shall be provided as follows:
\indexlibrary{\idxcode{numeric_limits<bool>}}%
\begin{codeblock}
namespace std {
   template<> class numeric_limits<bool> {
   public:
     static constexpr bool is_specialized = true;
     static constexpr bool min() noexcept { return false; }
     static constexpr bool max() noexcept { return true; }
     static constexpr bool lowest() noexcept { return false; }

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

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

     static constexpr int  min_exponent = 0;
     static constexpr int  min_exponent10 = 0;
     static constexpr int  max_exponent = 0;
     static constexpr int  max_exponent10 = 0;

     static constexpr bool has_infinity = false;
     static constexpr bool has_quiet_NaN = false;
     static constexpr bool has_signaling_NaN = false;
     static constexpr float_denorm_style has_denorm = denorm_absent;
     static constexpr bool has_denorm_loss = false;
     static constexpr bool infinity() noexcept { return 0; }
     static constexpr bool quiet_NaN() noexcept { return 0; }
     static constexpr bool signaling_NaN() noexcept { return 0; }
     static constexpr bool denorm_min() noexcept { return 0; }

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

     static constexpr bool traps = false;
     static constexpr bool tinyness_before = false;
     static constexpr float_round_style round_style = round_toward_zero;
   };
}
\end{codeblock}

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

\indexlibrary{\idxcode{CHAR_BIT}}%
\indexlibrary{\idxcode{SCHAR_MIN}}%
\indexlibrary{\idxcode{SCHAR_MAX}}%
\indexlibrary{\idxcode{UCHAR_MAX}}%
\indexlibrary{\idxcode{CHAR_MIN}}%
\indexlibrary{\idxcode{CHAR_MAX}}%
\indexlibrary{\idxcode{MB_LEN_MAX}}%
\indexlibrary{\idxcode{SHRT_MIN}}%
\indexlibrary{\idxcode{SHRT_MAX}}%
\indexlibrary{\idxcode{USHRT_MAX}}%
\indexlibrary{\idxcode{INT_MIN}}%
\indexlibrary{\idxcode{INT_MAX}}%
\indexlibrary{\idxcode{UINT_MAX}}%
\indexlibrary{\idxcode{LONG_MIN}}%
\indexlibrary{\idxcode{LONG_MAX}}%
\indexlibrary{\idxcode{ULONG_MAX}}%
\indexlibrary{\idxcode{LLONG_MIN}}%
\indexlibrary{\idxcode{LLONG_MAX}}%
\indexlibrary{\idxcode{ULLONG_MAX}}%
\begin{codeblock}
#define CHAR_BIT @\seebelow@
#define SCHAR_MIN @\seebelow@
#define SCHAR_MAX @\seebelow@
#define UCHAR_MAX @\seebelow@
#define CHAR_MIN @\seebelow@
#define CHAR_MAX @\seebelow@
#define MB_LEN_MAX @\seebelow@
#define SHRT_MIN @\seebelow@
#define SHRT_MAX @\seebelow@
#define USHRT_MAX @\seebelow@
#define INT_MIN @\seebelow@
#define INT_MAX @\seebelow@
#define UINT_MAX @\seebelow@
#define LONG_MIN @\seebelow@
#define LONG_MAX @\seebelow@
#define ULONG_MAX @\seebelow@
#define LLONG_MIN @\seebelow@
#define LLONG_MAX @\seebelow@
#define ULLONG_MAX @\seebelow@
\end{codeblock}

\pnum
The header \tcode{<climits>} defines all macros the same as
the C standard library header \tcode{<limits.h>}.
\begin{note}
The types of the constants defined by macros in \tcode{<climits>} are not
required to match the types to which the macros refer.
\end{note}

\xrefc{5.2.4.2.1}

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

\indexlibrary{\idxcode{DBL_DECIMAL_DIG}}%
\indexlibrary{\idxcode{DBL_DIG}}%
\indexlibrary{\idxcode{DBL_EPSILON}}%
\indexlibrary{\idxcode{DBL_HAS_SUBNORM}}%
\indexlibrary{\idxcode{DBL_MANT_DIG}}%
\indexlibrary{\idxcode{DBL_MAX}}%
\indexlibrary{\idxcode{DBL_MAX_10_EXP}}%
\indexlibrary{\idxcode{DBL_MAX_EXP}}%
\indexlibrary{\idxcode{DBL_MIN}}%
\indexlibrary{\idxcode{DBL_MIN_10_EXP}}%
\indexlibrary{\idxcode{DBL_MIN_EXP}}%
\indexlibrary{\idxcode{DBL_TRUE_MIN}}%
\indexlibrary{\idxcode{DECIMAL_DIG}}%
\indexlibrary{\idxcode{FLT_DECIMAL_DIG}}%
\indexlibrary{\idxcode{FLT_DIG}}%
\indexlibrary{\idxcode{FLT_EPSILON}}%
\indexlibrary{\idxcode{FLT_EVAL_METHOD}}%
\indexlibrary{\idxcode{FLT_HAS_SUBNORM}}%
\indexlibrary{\idxcode{FLT_MANT_DIG}}%
\indexlibrary{\idxcode{FLT_MAX}}%
\indexlibrary{\idxcode{FLT_MAX_10_EXP}}%
\indexlibrary{\idxcode{FLT_MAX_EXP}}%
\indexlibrary{\idxcode{FLT_MIN}}%
\indexlibrary{\idxcode{FLT_MIN_10_EXP}}%
\indexlibrary{\idxcode{FLT_MIN_EXP}}%
\indexlibrary{\idxcode{FLT_RADIX}}%
\indexlibrary{\idxcode{FLT_ROUNDS}}%
\indexlibrary{\idxcode{FLT_TRUE_MIN}}%
\indexlibrary{\idxcode{LDBL_DECIMAL_DIG}}%
\indexlibrary{\idxcode{LDBL_DIG}}%
\indexlibrary{\idxcode{LDBL_EPSILON}}%
\indexlibrary{\idxcode{LDBL_HAS_SUBNORM}}%
\indexlibrary{\idxcode{LDBL_MANT_DIG}}%
\indexlibrary{\idxcode{LDBL_MAX}}%
\indexlibrary{\idxcode{LDBL_MAX_10_EXP}}%
\indexlibrary{\idxcode{LDBL_MAX_EXP}}%
\indexlibrary{\idxcode{LDBL_MIN}}%
\indexlibrary{\idxcode{LDBL_MIN_10_EXP}}%
\indexlibrary{\idxcode{LDBL_MIN_EXP}}%
\indexlibrary{\idxcode{LDBL_TRUE_MIN}}%
\begin{codeblock}
#define FLT_ROUNDS @\seebelow@
#define FLT_EVAL_METHOD @\seebelow@
#define FLT_HAS_SUBNORM @\seebelow@
#define DBL_HAS_SUBNORM @\seebelow@
#define LDBL_HAS_SUBNORM @\seebelow@
#define FLT_RADIX @\seebelow@
#define FLT_MANT_DIG @\seebelow@
#define DBL_MANT_DIG @\seebelow@
#define LDBL_MANT_DIG @\seebelow@
#define FLT_DECIMAL_DIG @\seebelow@
#define DBL_DECIMAL_DIG @\seebelow@
#define LDBL_DECIMAL_DIG @\seebelow@
#define DECIMAL_DIG @\seebelow@
#define FLT_DIG @\seebelow@
#define DBL_DIG @\seebelow@
#define LDBL_DIG @\seebelow@
#define FLT_MIN_EXP @\seebelow@
#define DBL_MIN_EXP @\seebelow@
#define LDBL_MIN_EXP @\seebelow@
#define FLT_MIN_10_EXP @\seebelow@
#define DBL_MIN_10_EXP @\seebelow@
#define LDBL_MIN_10_EXP @\seebelow@
#define FLT_MAX_EXP @\seebelow@
#define DBL_MAX_EXP @\seebelow@
#define LDBL_MAX_EXP @\seebelow@
#define FLT_MAX_10_EXP @\seebelow@
#define DBL_MAX_10_EXP @\seebelow@
#define LDBL_MAX_10_EXP @\seebelow@
#define FLT_MAX @\seebelow@
#define DBL_MAX @\seebelow@
#define LDBL_MAX @\seebelow@
#define FLT_EPSILON @\seebelow@
#define DBL_EPSILON @\seebelow@
#define LDBL_EPSILON @\seebelow@
#define FLT_MIN @\seebelow@
#define DBL_MIN @\seebelow@
#define LDBL_MIN @\seebelow@
#define FLT_TRUE_MIN @\seebelow@
#define DBL_TRUE_MIN @\seebelow@
#define LDBL_TRUE_MIN @\seebelow@
\end{codeblock}

\pnum
The header \tcode{<cfloat>} defines all macros the same as
the C standard library header \tcode{<float.h>}.

\xrefc{5.2.4.2.2}

\rSec1[cstdint]{Integer types}

\rSec2[cstdint.syn]{Header \tcode{<cstdint>} synopsis}
\indexhdr{cstdint}%
\indexlibrary{\idxcode{int8_t}}%
\indexlibrary{\idxcode{int16_t}}%
\indexlibrary{\idxcode{int32_t}}%
\indexlibrary{\idxcode{int64_t}}%
\indexlibrary{\idxcode{int_fast8_t}}%
\indexlibrary{\idxcode{int_fast16_t}}%
\indexlibrary{\idxcode{int_fast32_t}}%
\indexlibrary{\idxcode{int_fast64_t}}%
\indexlibrary{\idxcode{int_least8_t}}%
\indexlibrary{\idxcode{int_least16_t}}%
\indexlibrary{\idxcode{int_least32_t}}%
\indexlibrary{\idxcode{int_least64_t}}%
\indexlibrary{\idxcode{intmax_t}}%
\indexlibrary{\idxcode{intptr_t}}%
\indexlibrary{\idxcode{uint8_t}}%
\indexlibrary{\idxcode{uint16_t}}%
\indexlibrary{\idxcode{uint32_t}}%
\indexlibrary{\idxcode{uint64_t}}%
\indexlibrary{\idxcode{uint_fast8_t}}%
\indexlibrary{\idxcode{uint_fast16_t}}%
\indexlibrary{\idxcode{uint_fast32_t}}%
\indexlibrary{\idxcode{uint_fast64_t}}%
\indexlibrary{\idxcode{uint_least8_t}}%
\indexlibrary{\idxcode{uint_least16_t}}%
\indexlibrary{\idxcode{uint_least32_t}}%
\indexlibrary{\idxcode{uint_least64_t}}%
\indexlibrary{\idxcode{uintmax_t}}%
\indexlibrary{\idxcode{uintptr_t}}%

\begin{codeblock}
namespace std {
  using int8_t         = @\textit{signed integer type}@;  // optional
  using int16_t        = @\textit{signed integer type}@;  // optional
  using int32_t        = @\textit{signed integer type}@;  // optional
  using int64_t        = @\textit{signed integer type}@;  // optional

  using int_fast8_t    = @\textit{signed integer type}@;
  using int_fast16_t   = @\textit{signed integer type}@;
  using int_fast32_t   = @\textit{signed integer type}@;
  using int_fast64_t   = @\textit{signed integer type}@;

  using int_least8_t   = @\textit{signed integer type}@;
  using int_least16_t  = @\textit{signed integer type}@;
  using int_least32_t  = @\textit{signed integer type}@;
  using int_least64_t  = @\textit{signed integer type}@;

  using intmax_t       = @\textit{signed integer type}@;
  using intptr_t       = @\textit{signed integer type}@;   // optional

  using uint8_t        = @\textit{unsigned integer type}@; // optional
  using uint16_t       = @\textit{unsigned integer type}@; // optional
  using uint32_t       = @\textit{unsigned integer type}@; // optional
  using uint64_t       = @\textit{unsigned integer type}@; // optional

  using uint_fast8_t   = @\textit{unsigned integer type}@;
  using uint_fast16_t  = @\textit{unsigned integer type}@;
  using uint_fast32_t  = @\textit{unsigned integer type}@;
  using uint_fast64_t  = @\textit{unsigned integer type}@;

  using uint_least8_t  = @\textit{unsigned integer type}@;
  using uint_least16_t = @\textit{unsigned integer type}@;
  using uint_least32_t = @\textit{unsigned integer type}@;
  using uint_least64_t = @\textit{unsigned integer type}@;

  using uintmax_t      = @\textit{unsigned integer type}@;
  using uintptr_t      = @\textit{unsigned integer type}@; // optional
}
\end{codeblock}

\pnum
The header also defines numerous macros of the form:

\begin{codeblock}
  INT_[FAST LEAST]{8 16 32 64}_MIN
  [U]INT_[FAST LEAST]{8 16 32 64}_MAX
  INT{MAX PTR}_MIN
  [U]INT{MAX PTR}_MAX
  {PTRDIFF SIG_ATOMIC WCHAR WINT}{_MAX _MIN}
  SIZE_MAX
\end{codeblock}

plus function macros of the form:

\begin{codeblock}
  [U]INT{8 16 32 64 MAX}_C
\end{codeblock}

\pnum
The header defines all types and macros the same as
the C standard library header \tcode{<stdint.h>}.

\xrefc{7.20}

\rSec1[support.start.term]{Start and termination}

\pnum
\indexhdr{cstdlib}%
\begin{note}
The header \tcode{<cstdlib>}\iref{cstdlib.syn}
declares the functions described in this subclause.
\end{note}

\indexlibrary{\idxcode{_Exit}}%
\begin{itemdecl}
[[noreturn]] void _Exit(int status) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
This function has the semantics specified in the C standard library.

\pnum
\remarks
The program is terminated without executing destructors for objects of automatic,
thread, or static storage duration and without calling functions passed to
\tcode{atexit()}\iref{basic.start.term}.
\indextext{signal-safe!\idxcode{_Exit}}%
The function \tcode{_Exit} is signal-safe\iref{support.signal}.
\end{itemdescr}

\indexlibrary{\idxcode{abort}}%
\begin{itemdecl}
[[noreturn]] void abort() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
This function has the semantics specified in the C standard library.

\pnum
\remarks
The program is terminated without executing destructors for objects of
automatic, thread, or static storage
duration and without calling functions passed to
\tcode{atexit()}\iref{basic.start.term}.
\indextext{signal-safe!\idxcode{abort}}%
The function \tcode{abort} is signal-safe\iref{support.signal}.
\end{itemdescr}

\indexlibrary{\idxcode{atexit}}%
\begin{itemdecl}
int atexit(@\placeholder{c-atexit-handler}@* f) noexcept;
int atexit(@\placeholder{atexit-handler}@* f) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
\tcode{atexit()}
functions register the function pointed to by \tcode{f}
to be called without arguments at normal program termination.
It is unspecified whether a call to \tcode{atexit()} that does not
happen before\iref{intro.multithread} a call to \tcode{exit()} will succeed.
\begin{note} The \tcode{atexit()} functions do not introduce a data
race\iref{res.on.data.races}. \end{note}

\pnum
\implimits
The implementation shall support the registration of at least 32 functions.

\pnum
\returns
The
\tcode{atexit()}
function returns zero if the registration succeeds,
nonzero if it fails.
\end{itemdescr}

\indexlibrary{\idxcode{exit}}%
\begin{itemdecl}
[[noreturn]] void exit(int status);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
\begin{itemize}
\item
First, objects with thread storage duration and associated with the current thread
are destroyed. Next, objects with static storage duration are destroyed
and functions registered by calling
\tcode{atexit}
are called.\footnote{A function is called for every time it is registered.}
See~\ref{basic.start.term} for the order of destructions and calls.
(Automatic objects are not destroyed as a result of calling
\tcode{exit()}.)\footnote{Objects with automatic storage duration are all destroyed in a program whose
\tcode{main} function\iref{basic.start.main}
contains no automatic objects and executes the call to
\tcode{exit()}.
Control can be transferred directly to such a
\tcode{main} function
by throwing an exception that is caught in
\tcode{main}.}

If control leaves a registered function called by \tcode{exit} because the function does
not provide a handler for a thrown exception, the function \tcode{std::terminate} shall be called\iref{except.terminate}.%
\indexlibrary{\idxcode{terminate}}%

\item
Next, all open C streams (as mediated by the function
signatures declared in
\tcode{<cstdio>})
with unwritten buffered data are flushed, all open C
streams are closed, and all files created by calling
\tcode{tmpfile()}
are removed.

\item
Finally, control is returned to the host environment.
If \tcode{status} is zero or
\tcode{EXIT_SUCCESS},
an \impldef{exit status}
form of the status
\term{successful termination}
is returned.
If \tcode{status} is
\tcode{EXIT_FAILURE},
an \impldef{exit status} form of the status
\term{unsuccessful termination}
is returned.
Otherwise the status returned is \impldef{exit status}.\footnote{The macros
\tcode{EXIT_FAILURE}
and
\tcode{EXIT_SUCCESS}
are defined in
\tcode{<cstdlib>}.}
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{at_quick_exit}}%
\begin{itemdecl}
int at_quick_exit(@\placeholder{c-atexit-handler}@* f) noexcept;
int at_quick_exit(@\placeholder{atexit-handler}@* f) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects The \tcode{at_quick_exit()} functions register the function pointed to by \tcode{f}
to be called without arguments when \tcode{quick_exit} is called.
It is unspecified whether a call to \tcode{at_quick_exit()} that does not
happen before\iref{intro.multithread} all calls to \tcode{quick_exit} will succeed. \begin{note} The
\tcode{at_quick_exit()} functions do not introduce a
data race\iref{res.on.data.races}. \end{note}
\begin{note}
The order of registration may be indeterminate if \tcode{at_quick_exit} was called from more
than one thread.
\end{note}
\begin{note} The
\tcode{at_quick_exit} registrations are distinct from the \tcode{atexit} registrations,
and applications may need to call both registration functions with the same argument.
\end{note}

\pnum
\implimits
The implementation shall support the registration of at least 32 functions.

\pnum
\returns Zero if the registration succeeds, nonzero if it fails.
\end{itemdescr}

\indexlibrary{\idxcode{quick_exit}}%
\begin{itemdecl}
[[noreturn]] void quick_exit(int status) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Functions registered by calls to \tcode{at_quick_exit} are called in the
reverse order of their registration, except that a function shall be called after any
previously registered functions that had already been called at the time it was
registered. Objects shall not be destroyed as a result of calling \tcode{quick_exit}.
If control leaves a registered function called by \tcode{quick_exit} because the
function does not provide a handler for a thrown exception, the function \tcode{std::terminate} shall
be called.\indexlibrary{\idxcode{terminate}}
\begin{note}
A function registered via \tcode{at_quick_exit}
is invoked by the thread that calls \tcode{quick_exit},
which can be a different thread
than the one that registered it, so registered functions should not rely on the identity
of objects with thread storage duration.
\end{note}
After calling registered functions, \tcode{quick_exit} shall call \tcode{_Exit(status)}.

\pnum
\remarks
\indextext{signal-safe!\idxcode{quick_exit}}%
The function \tcode{quick_exit} is signal-safe\iref{support.signal}
when the functions registered with \tcode{at_quick_exit} are.
\end{itemdescr}

\xrefc{7.22.4}

\rSec1[support.dynamic]{Dynamic memory management}

\pnum
The header
\tcode{<new>}
defines several
functions that manage the allocation of dynamic storage in a program.
It also defines components for reporting storage management errors.

\rSec2[new.syn]{Header \tcode{<new>} synopsis}
\indexhdr{new}%
\indexlibrary{\idxcode{align_val_t}}%
\indexlibrary{\idxcode{destroying_delete_t}}%
\indexlibrary{\idxcode{destroying_delete}}%
\indexlibrary{\idxcode{nothrow_t}}%
\indexlibrary{\idxcode{nothrow}}%
\begin{codeblock}
namespace std {
  class bad_alloc;
  class bad_array_new_length;

  struct destroying_delete_t {
    explicit destroying_delete_t() = default;
  };
  inline constexpr destroying_delete_t destroying_delete{};

  enum class align_val_t : size_t {};

  struct nothrow_t { explicit nothrow_t() = default; };
  extern const nothrow_t nothrow;

  using new_handler = void (*)();
  new_handler get_new_handler() noexcept;
  new_handler set_new_handler(new_handler new_p) noexcept;

  // \ref{ptr.launder}, pointer optimization barrier
  template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;

  // \ref{hardware.interference}, hardware interference size
  inline constexpr size_t hardware_destructive_interference_size = @\impdef{}@;
  inline constexpr size_t hardware_constructive_interference_size = @\impdef{}@;
}

[[nodiscard]] void* operator new(std::size_t size);
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment,
                                 const std::nothrow_t&) noexcept;

void  operator delete(void* ptr) noexcept;
void  operator delete(void* ptr, std::size_t size) noexcept;
void  operator delete(void* ptr, std::align_val_t alignment) noexcept;
void  operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
void  operator delete(void* ptr, const std::nothrow_t&) noexcept;
void  operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;

[[nodiscard]] void* operator new[](std::size_t size);
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment,
                                   const std::nothrow_t&) noexcept;

void  operator delete[](void* ptr) noexcept;
void  operator delete[](void* ptr, std::size_t size) noexcept;
void  operator delete[](void* ptr, std::align_val_t alignment) noexcept;
void  operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;
void  operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;

[[nodiscard]] void* operator new  (std::size_t size, void* ptr) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
void  operator delete  (void* ptr, void*) noexcept;
void  operator delete[](void* ptr, void*) noexcept;
\end{codeblock}

\rSec2[new.delete]{Storage allocation and deallocation}

\pnum
Except where otherwise specified, the provisions of~\ref{basic.stc.dynamic}
apply to the library versions of \tcode{operator new} and \tcode{operator
delete}.
If the value of an alignment argument
passed to any of these functions
is not a valid alignment value,
the behavior is undefined.

\newcommand{\replaceabledesc}[1]{%
A \Cpp{} program may define functions with #1 of these function signatures,
and thereby displace the default versions defined by the
\Cpp{} standard library.%
}

\rSec3[new.delete.single]{Single-object forms}

\indexlibrary{\idxcode{new}!\idxcode{operator}}%
\begin{itemdecl}
[[nodiscard]] void* operator new(std::size_t size);
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
allocation functions\iref{basic.stc.dynamic.allocation}
called by a
\grammarterm{new-expression}\iref{expr.new}
to allocate
\tcode{size} bytes of storage.
The second form is called for a type with new-extended alignment,
and allocates storage
with the specified alignment.
The first form is called otherwise,
and allocates storage
suitably aligned to represent any object of that size
provided the object's type does not have new-extended alignment.

\pnum
\replaceable
\replaceabledesc{either}

\pnum
\required
Return a non-null pointer to suitably aligned storage\iref{basic.stc.dynamic},
or else throw a
\tcode{bad_alloc}
\indexlibrary{\idxcode{bad_alloc}}%
exception.
This requirement is binding on any replacement versions of these functions.

\pnum
\default

\begin{itemize}
\item
Executes a loop:
Within the loop, the function first attempts to allocate the requested storage.
Whether the attempt involves a call to the C standard library functions
\tcode{malloc} or \tcode{aligned_alloc}
is unspecified.
\indextext{unspecified}%
\item
Returns a pointer to the allocated storage if the attempt is successful.
Otherwise, if the
current \tcode{new_handler}\iref{get.new.handler} is
a null pointer value, throws
\tcode{bad_alloc}.
\item
Otherwise, the function calls the current
\tcode{new_handler} function\iref{new.handler}.
If the called function returns, the loop repeats.
\item
The loop terminates when an attempt to allocate the requested storage is
successful or when a called
\tcode{new_handler}
function does not return.
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{new}!\idxcode{operator}}%
\begin{itemdecl}
[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment,
                                 const std::nothrow_t&) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Same as above, except that these are called by a placement version of a
\grammarterm{new-expression}
when a \Cpp{} program prefers a null pointer result as an error indication,
instead of a
\tcode{bad_alloc}
exception.

\pnum
\replaceable
\replaceabledesc{either}

\pnum
\required
Return a non-null pointer to suitably aligned storage\iref{basic.stc.dynamic},
or else return a null pointer.
Each of these nothrow versions of
\tcode{operator new}
returns a pointer obtained as if
acquired from the (possibly replaced)
corresponding non-placement function.
This requirement is binding on any replacement versions of these functions.

\pnum
\default
Calls \tcode{operator new(size)},
or \tcode{operator new(size, alignment)},
respectively.
If the call returns normally,
returns the result of that call.
Otherwise, returns a null pointer.

\pnum
\begin{example}
\begin{codeblock}
T* p1 = new T;                  // throws \tcode{bad_alloc} if it fails
T* p2 = new(nothrow) T;         // returns \tcode{nullptr} if it fails
\end{codeblock}
\end{example}
\end{itemdescr}

\indexlibrary{\idxcode{delete}!\idxcode{operator}}%
\begin{itemdecl}
void operator delete(void* ptr) noexcept;
void operator delete(void* ptr, std::size_t size) noexcept;
void operator delete(void* ptr, std::align_val_t alignment) noexcept;
void operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
deallocation functions\iref{basic.stc.dynamic.deallocation}
called by a
\grammarterm{delete-expression}\iref{expr.delete}
to render the value of \tcode{ptr} invalid.

\pnum
\replaceable
\replaceabledesc{any}
If a function without a \tcode{size} parameter is defined,
the program should also define
the corresponding function with a \tcode{size} parameter.
If a function with a \tcode{size} parameter is defined,
the program shall also define
the corresponding version without the \tcode{size} parameter.
\begin{note}
The default behavior below may change in the future, which will require
replacing both deallocation functions when replacing the allocation function.
\end{note}

\pnum
\expects
\tcode{ptr} is a null pointer or
its value represents the address of
a block of memory allocated by
an earlier call to a (possibly replaced)
\tcode{operator new(std::size_t)}
or
\tcode{operator new(std::size_t, std::align_val_t)}
which has not been invalidated by an intervening call to
\tcode{operator delete}.

\pnum
\expects
If an implementation has strict pointer safety\iref{basic.stc.dynamic.safety}
then \tcode{ptr} is a safely-derived pointer.

\pnum
\expects
If the \tcode{alignment} parameter is not present,
\tcode{ptr} was returned by an allocation function
without an \tcode{alignment} parameter.
If present, the \tcode{alignment} argument
is equal to the \tcode{alignment} argument
passed to the allocation function that returned \tcode{ptr}.
If present, the \tcode{size} argument
is equal to the \tcode{size} argument
passed to the allocation function that returned \tcode{ptr}.

\pnum
\required
A call to an \tcode{operator delete}
with a \tcode{size} parameter
may be changed to
a call to the corresponding \tcode{operator delete}
without a \tcode{size} parameter,
without affecting memory allocation.
\begin{note} A conforming implementation is for
\tcode{operator delete(void* ptr, std::size_t size)} to simply call
\tcode{operator delete(ptr)}. \end{note}

\pnum
\default
The functions that have a \tcode{size} parameter
forward their other parameters
to the corresponding function without a \tcode{size} parameter.
\begin{note} See the note in the above \replaceable paragraph. \end{note}

\pnum
\default
If \tcode{ptr} is null, does nothing. Otherwise, reclaims the
storage allocated by the earlier call to \tcode{operator new}.

\pnum
\remarks
It is unspecified under what conditions part or all of such
\indextext{unspecified}%
reclaimed storage will be allocated by subsequent
calls to
\tcode{operator new}
or any of
\tcode{aligned_alloc},
\tcode{calloc},
\tcode{malloc},
or
\tcode{realloc},
declared in
\tcode{<cstdlib>}.
\end{itemdescr}

\indexlibrary{\idxcode{delete}!\idxcode{operator}}%
\begin{itemdecl}
void operator delete(void* ptr, const std::nothrow_t&) noexcept;
void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
deallocation functions\iref{basic.stc.dynamic.deallocation}
called by the implementation
to render the value of \tcode{ptr} invalid
when the constructor invoked from a nothrow
placement version of the \grammarterm{new-expression} throws an exception.

\pnum
\replaceable
\replaceabledesc{either}

\pnum
\expects
\tcode{ptr} is a null pointer or
its value represents the address of
a block of memory allocated by
an earlier call to a (possibly replaced)
\tcode{operator new(std::size_t)}
or
\tcode{operator new(std::size_t, std::align_val_t)}
which has not been invalidated by an intervening call to
\tcode{operator delete}.

\pnum
\expects
If an implementation has strict pointer safety\iref{basic.stc.dynamic.safety}
then \tcode{ptr} is a safely-derived pointer.

\pnum
\expects
If the \tcode{alignment} parameter is not present,
\tcode{ptr} was returned by an allocation function
without an \tcode{alignment} parameter.
If present, the \tcode{alignment} argument
is equal to the \tcode{alignment} argument
passed to the allocation function that returned \tcode{ptr}.

\pnum
\default
Calls \tcode{operator delete(ptr)},
or \tcode{operator delete(ptr, alignment)},
respectively.
\end{itemdescr}

\rSec3[new.delete.array]{Array forms}

\indexlibrary{\idxcode{new}!\idxcode{operator}}%
\begin{itemdecl}
[[nodiscard]] void* operator new[](std::size_t size);
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
allocation functions\iref{basic.stc.dynamic.allocation}
called by the array form of a
\grammarterm{new-expression}\iref{expr.new}
to allocate
\tcode{size} bytes of storage.
The second form is called for a type with new-extended alignment,
and allocates storage
with the specified alignment.
The first form is called otherwise,
and allocates storage
suitably aligned to represent any array object of that size or smaller,
provided the object's type does not have new-extended alignment.%
\footnote{It is not the direct responsibility of
\tcode{operator new[]}
or
\tcode{operator delete[]}
to note the repetition count or element size of the array.
Those operations are performed elsewhere in the array
\tcode{new}
and
\tcode{delete}
expressions.
The array
\tcode{new}
expression, may, however, increase the \tcode{size} argument to
\tcode{operator new[]}
to obtain space to store supplemental information.}

\pnum
\replaceable
\replaceabledesc{either}

\pnum
\required
Same as for
the corresponding single-object forms.
This requirement is binding on any replacement versions of these functions.

\pnum
\default
Returns
\tcode{operator new(size)},
or
\tcode{operator new(size, alignment)},
respectively.
\end{itemdescr}

\indexlibrary{\idxcode{new}!\idxcode{operator}}%
\begin{itemdecl}
[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment,
                                   const std::nothrow_t&) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Same as above, except that these are called by a placement version of a
\grammarterm{new-expression}
when a \Cpp{} program prefers a null pointer result as an error indication,
instead of a
\tcode{bad_alloc}
exception.

\pnum
\replaceable
\replaceabledesc{either}

\pnum
\required
Return a non-null pointer to suitably aligned storage\iref{basic.stc.dynamic},
or else return a null pointer.
Each of these nothrow versions of
\tcode{operator new[]}
returns a pointer obtained as if
acquired from the (possibly replaced)
corresponding non-placement function.
This requirement is binding on any replacement versions of these functions.

\pnum
\default
Calls \tcode{operator new[](size)},
or \tcode{operator new[](size, alignment)},
respectively.
If the call returns normally,
returns the result of that call.
Otherwise, returns a null pointer.
\end{itemdescr}

\indexlibrary{\idxcode{delete}!\idxcode{operator}}%
\begin{itemdecl}
void operator delete[](void* ptr) noexcept;
void operator delete[](void* ptr, std::size_t size) noexcept;
void operator delete[](void* ptr, std::align_val_t alignment) noexcept;
void operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
deallocation functions\iref{basic.stc.dynamic.deallocation}
called by the array form of a
\grammarterm{delete-expression}
to render the value of \tcode{ptr} invalid.

\pnum
\replaceable
\replaceabledesc{any}
If a function without a \tcode{size} parameter is defined,
the program should also define
the corresponding function with a \tcode{size} parameter.
If a function with a \tcode{size} parameter is defined,
the program shall also define
the corresponding version without the \tcode{size} parameter.
\begin{note}
The default behavior below may change in the future, which will require
replacing both deallocation functions when replacing the allocation function.
\end{note}

\pnum
\expects
\tcode{ptr} is a null pointer or
its value represents the address of
a block of memory allocated by
an earlier call to a (possibly replaced)
\tcode{operator new[](std::size_t)}
or
\tcode{operator new[](std::size_t, std::align_val_t)}
which has not been invalidated by an intervening call to
\tcode{operator delete[]}.

\pnum
\expects
If an implementation has strict pointer safety\iref{basic.stc.dynamic.safety}
then \tcode{ptr} is a safely-derived pointer.

\pnum
\expects
If the \tcode{alignment} parameter is not present,
\tcode{ptr} was returned by an allocation function
without an \tcode{alignment} parameter.
If present, the \tcode{alignment} argument
is equal to the \tcode{alignment} argument
passed to the allocation function that returned \tcode{ptr}.
If present, the \tcode{size} argument
is equal to the \tcode{size} argument
passed to the allocation function that returned \tcode{ptr}.

\pnum
\required
A call to an \tcode{operator delete[]}
with a \tcode{size} parameter
may be changed to
a call to the corresponding \tcode{operator delete[]}
without a \tcode{size} parameter,
without affecting memory allocation.
\begin{note} A conforming implementation is for
\tcode{operator delete[](void* ptr, std::size_t size)} to simply call
\tcode{operator delete[](ptr)}. \end{note}

\pnum
\default
The functions that have a \tcode{size} parameter
forward their other parameters
to the corresponding function without a \tcode{size} parameter.
The functions that do not have a \tcode{size} parameter
forward their parameters
to the corresponding \tcode{operator delete} (single-object) function.
\end{itemdescr}

\indexlibrary{\idxcode{delete}!\idxcode{operator}}%
\begin{itemdecl}
void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
The
deallocation functions\iref{basic.stc.dynamic.deallocation}
called by the implementation
to render the value of \tcode{ptr} invalid
when the constructor invoked from a nothrow
placement version of the array \grammarterm{new-expression} throws an exception.

\pnum
\replaceable
\replaceabledesc{either}

\pnum
\expects
\tcode{ptr} is a null pointer or
its value represents the address of
a block of memory allocated by
an earlier call to a (possibly replaced)
\tcode{operator new[](std::size_t)}
or
\tcode{operator new[](std::size_t, std::align_val_t)}
which has not been invalidated by an intervening call to
\tcode{operator delete[]}.

\pnum
\expects
If an implementation has strict pointer safety\iref{basic.stc.dynamic.safety}
then \tcode{ptr} is a safely-derived pointer.

\pnum
\expects
If the \tcode{alignment} parameter is not present,
\tcode{ptr} was returned by an allocation function
without an \tcode{alignment} parameter.
If present, the \tcode{alignment} argument
is equal to the \tcode{alignment} argument
passed to the allocation function that returned \tcode{ptr}.

\pnum
\default
Calls \tcode{operator delete[](ptr)},
or \tcode{operator delete[](ptr, alignment)},
respectively.
\end{itemdescr}

\rSec3[new.delete.placement]{Non-allocating forms}

\pnum
These functions are reserved; a \Cpp{} program may not define functions that displace
the versions in the \Cpp{} standard library\iref{constraints}.
The provisions of~\ref{basic.stc.dynamic} do not apply to these reserved
placement forms of \tcode{operator new} and \tcode{operator delete}.

\indexlibrary{\idxcode{new}!\idxcode{operator}}%
\begin{itemdecl}
[[nodiscard]] void* operator new(std::size_t size, void* ptr) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{ptr}.

\pnum
\remarks
Intentionally performs no other action.

\pnum
\begin{example}
This can be useful for constructing an object at a known address:

\begin{codeblock}
void* place = operator new(sizeof(Something));
Something* p = new (place) Something();
\end{codeblock}
\end{example}
\end{itemdescr}

\indexlibrary{\idxcode{new}!\idxcode{operator}}%
\begin{itemdecl}
[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{ptr}.

\pnum
\remarks
Intentionally performs no other action.
\end{itemdescr}

\indexlibrary{\idxcode{delete}!\idxcode{operator}}%
\begin{itemdecl}
void operator delete(void* ptr, void*) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Intentionally performs no action.

\pnum
\expects
If an implementation has strict pointer safety\iref{basic.stc.dynamic.safety}
then \tcode{ptr} is a safely-derived pointer.

\pnum
\remarks
Default function called when any part of the initialization in a
placement \grammarterm{new-expression} that invokes the library's
non-array placement operator new
terminates by throwing an exception\iref{expr.new}.
\end{itemdescr}

\indexlibrary{\idxcode{delete}!\idxcode{operator}}%
\begin{itemdecl}
void operator delete[](void* ptr, void*) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Intentionally performs no action.

\pnum
\expects
If an implementation has strict pointer safety\iref{basic.stc.dynamic.safety}
then \tcode{ptr} is a safely-derived pointer.

\pnum
\remarks
Default function called when any part of the initialization in a
placement \grammarterm{new-expression} that invokes the library's
array placement operator new
terminates by throwing an exception\iref{expr.new}.
\end{itemdescr}

\rSec3[new.delete.dataraces]{Data races}

\pnum
For purposes of determining the existence of data races, the library versions
of \tcode{operator new}, user replacement versions of global \tcode{operator new},
the C standard library functions
\tcode{aligned_alloc}, \tcode{calloc}, and \tcode{malloc},
the library
versions of \tcode{operator delete}, user replacement
versions of \tcode{operator delete}, the C standard library function
\tcode{free}, and the C standard library function \tcode{realloc} shall not
introduce a data race\iref{res.on.data.races}.
Calls to these functions that allocate or deallocate a particular unit
of storage shall occur in a single total order, and each such deallocation call
shall happen before\iref{intro.multithread} the next allocation (if any) in
this order.

\rSec2[alloc.errors]{Storage allocation errors}

\indexlibrary{\idxcode{bad_alloc}}%
\rSec3[bad.alloc]{Class \tcode{bad_alloc}}

\indexlibrary{\idxcode{bad_alloc}!constructor}%
\begin{codeblock}
namespace std {
  class bad_alloc : public exception {
  public:
    bad_alloc() noexcept;
    bad_alloc(const bad_alloc&) noexcept;
    bad_alloc& operator=(const bad_alloc&) noexcept;
    const char* what() const noexcept override;
  };
}
\end{codeblock}

\pnum
The class
\tcode{bad_alloc}
defines the type of objects thrown as
exceptions by the implementation to report a failure to allocate storage.

\indexlibrarymember{what}{bad_alloc}%
\begin{itemdecl}
const char* what() const noexcept override;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{bad_alloc::what}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt}).
\end{itemdescr}

\indexlibrary{\idxcode{bad_array_new_length}}%
\indexlibrary{\idxcode{bad_array_new_length}!constructor}%
\rSec3[new.badlength]{Class \tcode{bad_array_new_length}}

\begin{codeblock}
namespace std {
  class bad_array_new_length : public bad_alloc {
  public:
    bad_array_new_length() noexcept;
    const char* what() const noexcept override;
  };
}
\end{codeblock}

\pnum
The class \tcode{bad_array_new_length} defines the type of objects thrown as
exceptions by the implementation to report an attempt to allocate an array of size
less than zero or
greater than an \impldef{maximum size of an allocated object} limit\iref{expr.new}.

\indexlibrarymember{what}{bad_array_new_length}%
\begin{itemdecl}
const char* what() const noexcept override;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{bad_array_new_length::what}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt}).
\end{itemdescr}

\rSec3[new.handler]{Type \tcode{new_handler}}

\indexlibrary{\idxcode{new_handler}}%
\begin{itemdecl}
using new_handler = void (*)();
\end{itemdecl}

\begin{itemdescr}
\pnum
The type of a
\term{handler function}
to be called by
\tcode{operator new()}
or
\tcode{operator new[]()}\iref{new.delete} when they cannot satisfy a request for additional storage.

\pnum
\required
A \tcode{new_handler} shall perform one of the following:

\begin{itemize}
\item
make more storage available for allocation and then return;
\item
throw an exception of type
\tcode{bad_alloc}
or a class derived from
\indexlibrary{\idxcode{bad_alloc}}%
\tcode{bad_alloc};
\item
terminate execution of the program without returning to the caller.
\indexlibrary{\idxcode{abort}}%
\indexlibrary{\idxcode{exit}}%
\end{itemize}
\end{itemdescr}

\rSec3[set.new.handler]{\tcode{set_new_handler}}

\indexlibrary{\idxcode{set_new_handler}}%
\begin{itemdecl}
new_handler set_new_handler(new_handler new_p) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Establishes the function designated by \tcode{new_p} as the current
\tcode{new_handler}.

\pnum
\returns
The previous \tcode{new_handler}.

\pnum
\remarks
The initial \tcode{new_handler} is a null pointer.
\end{itemdescr}

\rSec3[get.new.handler]{\tcode{get_new_handler}}

\indexlibrary{\idxcode{get_new_handler}}%
\begin{itemdecl}
new_handler get_new_handler() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The current \tcode{new_handler}.
\begin{note} This may be a null pointer value. \end{note}
\end{itemdescr}

\rSec2[ptr.launder]{Pointer optimization barrier}

\indexlibrary{\idxcode{launder}}%
\begin{itemdecl}
template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\mandates
\tcode{!is_function_v<T> \&\& !is_void_v<T>} is \tcode{true}.

\pnum
\expects
\tcode{p} represents the address \placeholder{A} of a byte in memory.
An object \placeholder{X} that is within its lifetime\iref{basic.life}
and whose type is similar\iref{conv.qual} to \tcode{T}
is located at the address \placeholder{A}.
All bytes of storage that would be reachable through the result
are reachable through \tcode{p} (see below).

\pnum
\returns
A value of type \tcode{T *} that points to \tcode{X}.

\pnum
\remarks
An invocation of this function
may be used in a core constant expression
whenever the value of its argument
may be used in a core constant expression.
A byte of storage is
reachable through a pointer value
that points to an object \placeholder{Y}
if it is within the storage occupied by
\placeholder{Y},
an object that is pointer-interconvertible with \placeholder{Y}, or
the immediately-enclosing array object if \placeholder{Y} is an array element.

\pnum
\begin{note}
If a new object is created
in storage occupied by an existing object of the same type,
a pointer to the original object
can be used to refer to the new object
unless the type contains \tcode{const} or reference members;
in the latter cases,
this function can be used to obtain a usable pointer to the new object.
See~\ref{basic.life}.
\end{note}

\pnum
\begin{example}
\begin{codeblock}
struct X { const int n; };
X *p = new X{3};
const int a = p->n;
new (p) X{5};                       // \tcode{p} does not point to new object\iref{basic.life} because \tcode{X::n} is \tcode{const}
const int b = p->n;                 // undefined behavior
const int c = std::launder(p)->n;   // OK
\end{codeblock}
\end{example}
\end{itemdescr}

\rSec2[hardware.interference]{Hardware interference size}

\indexlibrary{\idxcode{hardware_destructive_interference_size}}%
\begin{itemdecl}
inline constexpr size_t hardware_destructive_interference_size = @\impdef{}@;
\end{itemdecl}

\pnum
This number is the minimum recommended offset
between two concurrently-accessed objects
to avoid additional performance degradation due to contention
introduced by the implementation.
It shall be at least \tcode{alignof(max_align_t)}.

\indextext{cats!interfering with canines}%
\begin{example}
\begin{codeblock}
struct keep_apart {
  alignas(hardware_destructive_interference_size) atomic<int> cat;
  alignas(hardware_destructive_interference_size) atomic<int> dog;
};
\end{codeblock}
\end{example}

\indexlibrary{\idxcode{hardware_constructive_interference_size}}%
\begin{itemdecl}
inline constexpr size_t hardware_constructive_interference_size = @\impdef{}@;
\end{itemdecl}

\pnum
This number is the maximum recommended size of contiguous memory
occupied by two objects accessed with temporal locality by concurrent threads.
It shall be at least \tcode{alignof(max_align_t)}.

\indextext{dogs!obliviousness to interference}%
\begin{example}
\begin{codeblock}
struct together {
  atomic<int> dog;
  int puppy;
};
struct kennel {
  // Other data members...
  alignas(sizeof(together)) together pack;
  // Other data members...
};
static_assert(sizeof(together) <= hardware_constructive_interference_size);
\end{codeblock}
\end{example}

\rSec1[support.rtti]{Type identification}

\pnum
The header
\tcode{<typeinfo>}
defines a
type associated with type information generated by the implementation.
It also defines two types for reporting dynamic type identification errors.

\rSec2[typeinfo.syn]{Header \tcode{<typeinfo>} synopsis}
\indexhdr{typeinfo}%
\indexlibrary{\idxcode{type_info}}%
\indexlibrary{\idxcode{bad_cast}}%
\indexlibrary{\idxcode{bad_typeid}}%

\begin{codeblock}
namespace std {
  class type_info;
  class bad_cast;
  class bad_typeid;
}
\end{codeblock}

\rSec2[type.info]{Class \tcode{type_info}}

\indexlibrary{\idxcode{type_info}}%
\begin{codeblock}
namespace std {
  class type_info {
  public:
    virtual ~type_info();
    bool operator==(const type_info& rhs) const noexcept;
    bool operator!=(const type_info& rhs) const noexcept;
    bool before(const type_info& rhs) const noexcept;
    size_t hash_code() const noexcept;
    const char* name() const noexcept;

    type_info(const type_info& rhs) = delete;                   // cannot be copied
    type_info& operator=(const type_info& rhs) = delete;        // cannot be copied
  };
}
\end{codeblock}

\pnum
The class
\tcode{type_info}
describes type information generated by the implementation\iref{expr.typeid}.
Objects of this class effectively store a pointer to a name for the type, and
an encoded value suitable for comparing two types for equality or collating order.
The names, encoding rule, and collating sequence for types are all unspecified
\indextext{unspecified}%
and may differ between programs.

\indexlibrarymember{operator==}{type_info}%
\begin{itemdecl}
bool operator==(const type_info& rhs) const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares the current object with \tcode{rhs}.

\pnum
\returns
\tcode{true}
if the two values describe the same type.
\end{itemdescr}

\indexlibrarymember{operator"!=}{type_info}%
\begin{itemdecl}
bool operator!=(const type_info& rhs) const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{!(*this == rhs)}.
\end{itemdescr}

\indexlibrarymember{before}{type_info}%
\begin{itemdecl}
bool before(const type_info& rhs) const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares the current object with \tcode{rhs}.

\pnum
\returns
\tcode{true}
if
\tcode{*this}
precedes \tcode{rhs} in the implementation's collation order.
\end{itemdescr}

\indexlibrarymember{hash_code}{type_info}%
\begin{itemdecl}
size_t hash_code() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns An unspecified value, except that within a single execution of the
program, it shall return the same value for any two \tcode{type_info}
objects which compare equal.

\pnum
\remarks An implementation should return different values for two
\tcode{type_info} objects which do not compare equal.
\end{itemdescr}


\indexlibrarymember{name}{type_info}%
\begin{itemdecl}
const char* name() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{type_info::name()}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt})
\end{itemdescr}

\rSec2[bad.cast]{Class \tcode{bad_cast}}

\indexlibrary{\idxcode{bad_cast}}%
\indexlibrary{\idxcode{bad_cast}!constructor}%
\begin{codeblock}
namespace std {
  class bad_cast : public exception {
  public:
    bad_cast() noexcept;
    bad_cast(const bad_cast&) noexcept;
    bad_cast& operator=(const bad_cast&) noexcept;
    const char* what() const noexcept override;
  };
}
\end{codeblock}

\pnum
The class
\tcode{bad_cast}
defines the type of objects thrown
as exceptions by the implementation to report the execution of an invalid
\indextext{cast!dynamic}%
\tcode{dynamic_cast}
expression\iref{expr.dynamic.cast}.

\indexlibrarymember{what}{bad_cast}%
\begin{itemdecl}
const char* what() const noexcept override;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{bad_cast::what}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt})
\end{itemdescr}

\rSec2[bad.typeid]{Class \tcode{bad_typeid}}

\indexlibrary{\idxcode{bad_typeid}}%
\indexlibrary{\idxcode{bad_typeid}!constructor}%
\begin{codeblock}
namespace std {
  class bad_typeid : public exception {
  public:
    bad_typeid() noexcept;
    bad_typeid(const bad_typeid&) noexcept;
    bad_typeid& operator=(const bad_typeid&) noexcept;
    const char* what() const noexcept override;
  };
}
\end{codeblock}

\pnum
The class
\tcode{bad_typeid}
defines the type of objects
thrown as exceptions by the implementation to report a null pointer
in a
\tcode{typeid}
expression\iref{expr.typeid}.

\indexlibrarymember{what}{bad_typeid}%
\begin{itemdecl}
const char* what() const noexcept override;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{bad_typeid::what}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt})
\end{itemdescr}

\rSec1[support.contract]{Contract violation handling}

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

The header \tcode{<contract>} defines a type
for reporting information about contract violations
generated by the implementation.
\begin{codeblock}
namespace std {
  class contract_violation;
}
\end{codeblock}

\rSec2[support.contract.cviol]{Class \tcode{contract_violation}}
\indexlibrary{\idxcode{contract_violation}}%

\begin{codeblock}
namespace std {
  class contract_violation {
  public:
    uint_least32_t line_number() const noexcept;
    string_view file_name() const noexcept;
    string_view function_name() const noexcept;
    string_view comment() const noexcept;
    string_view assertion_level() const noexcept;
  };
}
\end{codeblock}

\pnum
The class \tcode{contract_violation} describes information about
a contract violation generated by the implementation.

\indexlibrarymember{line_number}{contract_violation}%
\begin{itemdecl}
uint_least32_t line_number() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The source code location
where the contract violation happened\iref{dcl.attr.contract}.
If the location is unknown, an implementation may return \tcode{0}.
\end{itemdescr}

\indexlibrarymember{file_name}{contract_violation}%
\begin{itemdecl}
string_view file_name() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The source file name
where the contract violation happened\iref{dcl.attr.contract}.
If the file name is unknown,
an implementation may return \tcode{string_view\{\}}.
\end{itemdescr}

\indexlibrarymember{function_name}{contract_violation}%
\begin{itemdecl}
string_view function_name() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The name of the function
where the contract violation happened\iref{dcl.attr.contract}.
If the function name is unknown,
an implementation may return \tcode{string_view\{\}}.
\end{itemdescr}

\indexlibrarymember{comment}{contract_violation}%
\begin{itemdecl}
string_view comment() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns Implementation-defined text describing
the predicate of the violated contract.
\end{itemdescr}

\indexlibrarymember{assertion_level}{contract_violation}%
\begin{itemdecl}
string_view assertion_level() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns Text describing the \grammarterm{assertion-level}
of the violated contract.
\end{itemdescr}

\rSec1[support.exception]{Exception handling}

\pnum
The header
\tcode{<exception>}
defines several types and functions related to the handling of exceptions in a \Cpp{} program.

\rSec2[exception.syn]{Header \tcode{<exception>} synopsis}
\indexhdr{exception}%

\begin{codeblock}
namespace std {
  class exception;
  class bad_exception;
  class nested_exception;

  using terminate_handler = void (*)();
  terminate_handler get_terminate() noexcept;
  terminate_handler set_terminate(terminate_handler f) noexcept;
  [[noreturn]] void terminate() noexcept;

  int uncaught_exceptions() noexcept;

  using exception_ptr = @\unspec@;

  exception_ptr current_exception() noexcept;
  [[noreturn]] void rethrow_exception(exception_ptr p);
  template<class E> exception_ptr make_exception_ptr(E e) noexcept;

  template<class T> [[noreturn]] void throw_with_nested(T&& t);
  template<class E> void rethrow_if_nested(const E& e);
}
\end{codeblock}

\rSec2[exception]{Class \tcode{exception}}

\indexlibrary{\idxcode{exception}}%
\indexlibrary{\idxcode{exception}!constructor}%
\begin{codeblock}
namespace std {
  class exception {
  public:
    exception() noexcept;
    exception(const exception&) noexcept;
    exception& operator=(const exception&) noexcept;
    virtual ~exception();
    virtual const char* what() const noexcept;
  };
}
\end{codeblock}

\pnum
The class
\tcode{exception}
defines the base
class for the types of objects thrown as exceptions by
\Cpp{} standard library components, and certain
expressions, to report errors detected during program execution.

\pnum
Each standard library class \tcode{T} that derives from class \tcode{exception} shall have a
publicly accessible copy constructor and a publicly accessible copy assignment
operator that do not exit with an exception. These member functions shall meet
the following postcondition: If two objects \tcode{lhs} and \tcode{rhs} both have
dynamic type \tcode{T} and \tcode{lhs} is a copy of \tcode{rhs}, then
\tcode{strcmp(lhs.what(), rhs.what())} shall equal 0.

\indexlibrary{\idxcode{exception}!constructor}%
\indexlibrarymember{operator=}{exception}%
\begin{itemdecl}
exception(const exception& rhs) noexcept;
exception& operator=(const exception& rhs) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\ensures If \tcode{*this} and \tcode{rhs} both have dynamic type \tcode{exception}
then the value of the expression \tcode{strcmp(what(), rhs.what())} shall equal 0.
\end{itemdescr}

\indexlibrary{\idxcode{exception}!destructor}%
\begin{itemdecl}
virtual ~exception();
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Destroys an object of class
\tcode{exception}.
\end{itemdescr}

\indexlibrarymember{what}{exception}%
\begin{itemdecl}
virtual const char* what() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{exception::what}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt}).
The return value remains valid until the exception object from which
it is obtained is destroyed or a non-\tcode{const}
member function of the exception object is called.
\end{itemdescr}

\rSec2[bad.exception]{Class \tcode{bad_exception}}

\indexlibrary{\idxcode{bad_exception}}%
\indexlibrary{\idxcode{bad_exception}!constructor}%
\begin{codeblock}
namespace std {
  class bad_exception : public exception {
  public:
    bad_exception() noexcept;
    bad_exception(const bad_exception&) noexcept;
    bad_exception& operator=(const bad_exception&) noexcept;
    const char* what() const noexcept override;
  };
}
\end{codeblock}

\pnum
The class
\tcode{bad_exception}
defines the type of the object
referenced by the \tcode{exception_ptr}
returned from a call to \tcode{current_exception}\iref{propagation}
when the currently active exception object fails to copy.

\indexlibrarymember{what}{bad_exception}%
\begin{itemdecl}
const char* what() const noexcept override;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
An \impldef{return value of \tcode{bad_exception::what}} \ntbs{}.

\pnum
\remarks
The message may be a null-terminated multibyte string\iref{multibyte.strings},
suitable for conversion and display as a
\tcode{wstring}~(\ref{string.classes}, \ref{locale.codecvt}).
\end{itemdescr}

\rSec2[exception.terminate]{Abnormal termination}

\rSec3[terminate.handler]{Type \tcode{terminate_handler}}

\indexlibrary{\idxcode{terminate_handler}}%
\begin{itemdecl}
using terminate_handler = void (*)();
\end{itemdecl}

\begin{itemdescr}
\pnum
The type of a
\term{handler function}
to be called by
\tcode{std::terminate()}
\indexlibrary{\idxcode{terminate}}%
when terminating exception processing.

\pnum
\required
A \tcode{terminate_handler} shall
terminate execution of the program without returning to the caller.

\pnum
\default
The implementation's default \tcode{terminate_handler} calls
\tcode{abort()}.%
\indexlibrary{\idxcode{abort}}%
\end{itemdescr}

\rSec3[set.terminate]{\tcode{set_terminate}}

\indexlibrary{\idxcode{set_terminate}}%
\begin{itemdecl}
terminate_handler set_terminate(terminate_handler f) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Establishes the function designated by \tcode{f} as the current
handler function for terminating exception processing.

\pnum
\remarks It is unspecified whether a null pointer value designates the default
\tcode{terminate_handler}.

\pnum
\returns
The previous \tcode{terminate_handler}.
\end{itemdescr}

\rSec3[get.terminate]{\tcode{get_terminate}}

\indexlibrary{\idxcode{get_terminate}}%
\begin{itemdecl}
terminate_handler get_terminate() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The current \tcode{terminate_handler}.
\begin{note} This may be a null pointer value. \end{note}
\end{itemdescr}

\rSec3[terminate]{\tcode{terminate}}

\indexlibrary{\idxcode{terminate}}%
\begin{itemdecl}
[[noreturn]] void terminate() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\remarks
Called by the implementation when exception
handling must be abandoned for any of several reasons\iref{except.terminate}.
May also be called directly by the program.

\pnum
\effects
Calls a \tcode{terminate_handler} function. It is unspecified which
\tcode{terminate_handler} function will be called if an exception is active
during a call to \tcode{set_terminate}.
Otherwise calls the current \tcode{terminate_handler} function. \begin{note} A
default \tcode{terminate_handler} is always considered a callable handler in
this context. \end{note}
\end{itemdescr}

\rSec2[uncaught.exceptions]{\tcode{uncaught_exceptions}}

\indexlibrary{\idxcode{uncaught_exceptions}}%
\begin{itemdecl}
int uncaught_exceptions() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
The number of uncaught exceptions\iref{except.uncaught}.

\pnum
\remarks
When \tcode{uncaught_exceptions() > 0},
throwing an exception can result in a call of the function
\tcode{std::terminate}\iref{except.terminate}.
\end{itemdescr}

\rSec2[propagation]{Exception propagation}

\indexlibrary{\idxcode{exception_ptr}}%
\begin{itemdecl}
using exception_ptr = @\unspec@;
\end{itemdecl}

\begin{itemdescr}
\pnum
The type \tcode{exception_ptr} can be used to refer to an exception object.

\pnum
\tcode{exception_ptr} meets the requirements of
\oldconcept{NullablePointer} (\tref{nullablepointer}).

\pnum
Two non-null values of type \tcode{exception_ptr} are equivalent and compare equal if and
only if they refer to the same exception.

\pnum
The default constructor of \tcode{exception_ptr} produces the null value of the
type.

\pnum
\tcode{exception_ptr} shall not be implicitly convertible to any arithmetic,
enumeration, or pointer type.

\pnum
\begin{note} An implementation might use a reference-counted smart
pointer as \tcode{exception_ptr}. \end{note}

\pnum
For purposes of determining the presence of a data race, operations on
\tcode{exception_ptr} objects shall access and modify only the
\tcode{exception_ptr} objects themselves and not the exceptions they refer to.
Use of \tcode{rethrow_exception} on \tcode{exception_ptr} objects that refer to
the same exception object shall not introduce a data race. \begin{note} If
\tcode{rethrow_exception} rethrows the same exception object (rather than a copy),
concurrent access to that rethrown exception object may introduce a data race.
Changes in the number of \tcode{exception_ptr} objects that refer to a
particular exception do not introduce a data race. \end{note}
\end{itemdescr}

\indexlibrary{\idxcode{current_exception}}%
\begin{itemdecl}
exception_ptr current_exception() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns An \tcode{exception_ptr} object that refers to
the currently handled exception\iref{except.handle} or a copy of the currently
handled exception, or a null \tcode{exception_ptr} object if no exception is being
handled. The referenced object shall remain valid at least as long as there is an
\tcode{exception_ptr} object that refers to it.
If the function needs to allocate memory and the attempt fails, it returns an
\tcode{exception_ptr} object that refers to an instance of \tcode{bad_alloc}.
It is unspecified whether the return values of two successive calls to
\tcode{current_exception} refer to the same exception object.
\begin{note} That is, it is unspecified whether \tcode{current_exception}
creates a new copy each time it is called. \end{note}
If the attempt to copy the current exception object throws an exception, the function
returns an \tcode{exception_ptr} object that refers to the thrown exception or,
if this is not possible, to an instance of \tcode{bad_exception}. \begin{note} The
copy constructor of the thrown exception may also fail, so the implementation is allowed
to substitute a \tcode{bad_exception} object to avoid infinite
recursion.\end{note}
\end{itemdescr}

\indexlibrary{\idxcode{rethrow_exception}}%
\begin{itemdecl}
[[noreturn]] void rethrow_exception(exception_ptr p);
\end{itemdecl}

\begin{itemdescr}
\pnum
\expects \tcode{p} is not a null pointer.

\pnum
\throws The exception object to which \tcode{p} refers.
\end{itemdescr}

\indexlibrary{\idxcode{make_exception_ptr}}%
\begin{itemdecl}
template<class E> exception_ptr make_exception_ptr(E e) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects Creates an \tcode{exception_ptr} object that refers to a copy of \tcode{e}, as if:
\begin{codeblock}
try {
  throw e;
} catch(...) {
  return current_exception();
}
\end{codeblock}

\pnum
\begin{note} This function is provided for convenience and
efficiency reasons. \end{note}
\end{itemdescr}

\rSec2[except.nested]{\tcode{nested_exception}}

\indexlibrary{\idxcode{nested_exception}}%
\begin{codeblock}
namespace std {
  class nested_exception {
  public:
    nested_exception() noexcept;
    nested_exception(const nested_exception&) noexcept = default;
    nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual ~nested_exception() = default;

    // access functions
    [[noreturn]] void rethrow_nested() const;
    exception_ptr nested_ptr() const noexcept;
  };

  template<class T> [[noreturn]] void throw_with_nested(T&& t);
  template<class E> void rethrow_if_nested(const E& e);
}
\end{codeblock}

\pnum
The class \tcode{nested_exception} is designed for use as a mixin through
multiple inheritance. It captures the currently handled exception and stores it
for later use.

\pnum
\begin{note} \tcode{nested_exception} has a virtual destructor to make it a
polymorphic class. Its presence can be tested for with \tcode{dynamic_cast}.
\end{note}

\indexlibrary{\idxcode{nested_exception}!constructor}%
\begin{itemdecl}
nested_exception() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects The constructor calls \tcode{current_exception()} and stores the returned value.
\end{itemdescr}

\indexlibrarymember{rethrow_nested}{nested_exception}%
\begin{itemdecl}
[[noreturn]] void rethrow_nested() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects If \tcode{nested_ptr()} returns a null pointer, the function calls the function \tcode{std::terminate}.
Otherwise, it throws the stored exception captured by \tcode{*this}.
\end{itemdescr}

\indexlibrarymember{nested_ptr}{nested_exception}%
\begin{itemdecl}
exception_ptr nested_ptr() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The stored exception captured by this \tcode{nested_exception} object.
\end{itemdescr}

\indexlibrarymember{throw_with_nested}{nested_exception}%
\begin{itemdecl}
template<class T> [[noreturn]] void throw_with_nested(T&& t);
\end{itemdecl}

\begin{itemdescr}
\pnum
Let \tcode{U} be \tcode{decay_t<T>}.

\pnum
\expects \tcode{U} meets the \oldconcept{CopyConstructible} requirements.

\pnum
\throws
If \tcode{is_class_v<U> \&\& !is_final_v<U> \&\& !is_base_of_v<nested_exception, U>}
is \tcode{true},
an exception of unspecified type that is publicly derived from both
\tcode{U} and \tcode{nested_exception}
and constructed from \tcode{std::forward<T>(t)}, otherwise
\tcode{std::forward<T>(t)}.
\end{itemdescr}

\indexlibrarymember{rethrow_if_nested}{nested_exception}%
\begin{itemdecl}
template<class E> void rethrow_if_nested(const E& e);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
If \tcode{E} is not a polymorphic class type, or
if \tcode{nested_exception} is an inaccessible or ambiguous base class of \tcode{E},
there is no effect.
Otherwise, performs:
\begin{codeblock}
if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
  p->rethrow_nested();
\end{codeblock}
\end{itemdescr}

\rSec1[support.initlist]{Initializer lists}

\indexhdr{initializer_list}%
\pnum
The header \tcode{<initializer_list>} defines a class template and several
support functions related to list-initialization~(see \ref{dcl.init.list}).
\indextext{signal-safe!\idxcode{initializer_list} functions}%
All functions specified in this subclause are signal-safe\iref{support.signal}.

\rSec2[initializer.list.syn]{Header \tcode{<initializer_list>} synopsis}
\indexlibrary{\idxcode{initializer_list}}%
\indexlibrary{\idxcode{begin}}%
\indexlibrary{\idxcode{end}}%

\begin{codeblock}
namespace std {
  template<class E> class initializer_list {
  public:
    using value_type      = E;
    using reference       = const E&;
    using const_reference = const E&;
    using size_type       = size_t;

    using iterator        = const E*;
    using const_iterator  = const E*;

    constexpr initializer_list() noexcept;

    constexpr size_t size() const noexcept;     // number of elements
    constexpr const E* begin() const noexcept;  // first element
    constexpr const E* end() const noexcept;    // one past the last element
  };

  // \ref{support.initlist.range}, initializer list range access
  template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
  template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
}
\end{codeblock}

\pnum
An object of type \tcode{initializer_list<E>} provides access to an array of
objects of type \tcode{const E}. \begin{note} A pair of pointers or a pointer plus
a length would be obvious representations for \tcode{initializer_list}.
\tcode{initializer_list} is used to implement initializer lists as specified
in~\ref{dcl.init.list}. Copying an initializer list does not copy the underlying
elements. \end{note}

\pnum
If an explicit specialization or partial specialization of
\tcode{initializer_list} is declared, the program is ill-formed.

\rSec2[support.initlist.cons]{Initializer list constructors}

\indexlibrary{\idxcode{initializer_list}!constructor}%
\begin{itemdecl}
constexpr initializer_list() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\ensures \tcode{size() == 0}.
\end{itemdescr}

\rSec2[support.initlist.access]{Initializer list access}

\indexlibrarymember{begin}{initializer_list}%
\begin{itemdecl}
constexpr const E* begin() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns A pointer to the beginning of the array. If \tcode{size() == 0} the
values of \tcode{begin()} and \tcode{end()} are unspecified but they shall be
identical.
\end{itemdescr}

\indexlibrarymember{end}{initializer_list}%
\begin{itemdecl}
constexpr const E* end() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns \tcode{begin() + size()}.
\end{itemdescr}

\indexlibrarymember{size}{initializer_list}%
\begin{itemdecl}
constexpr size_t size() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns The number of elements in the array.

\pnum
\complexity Constant time.
\end{itemdescr}

\rSec2[support.initlist.range]{Initializer list range access}

\indexlibrary{\idxcode{begin(initializer_list<E>)}}%
\begin{itemdecl}
template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns \tcode{il.begin()}.
\end{itemdescr}

\indexlibrary{\idxcode{end(initializer_list<E>)}}%
\begin{itemdecl}
template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns \tcode{il.end()}.
\end{itemdescr}

\rSec1[cmp]{Comparisons}

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

\pnum
The header \tcode{<compare>} specifies types, objects, and functions
for use primarily in connection with
the three-way comparison operator\iref{expr.spaceship}.

\indexhdr{compare}%
\indexlibrary{\idxcode{is_eq}}%
\indexlibrary{\idxcode{is_neq}}%
\indexlibrary{\idxcode{is_lt}}%
\indexlibrary{\idxcode{is_lteq}}%
\indexlibrary{\idxcode{is_gt}}%
\indexlibrary{\idxcode{is_geq}}%
\indexlibrary{\idxcode{is_gteq}}%
\indexlibrary{\idxcode{common_comparison_category_t}}%
\begin{codeblock}
namespace std {
  // \ref{cmp.categories}, comparison category types
  class weak_equality;
  class strong_equality;
  class partial_ordering;
  class weak_ordering;
  class strong_ordering;

  // named comparison functions
  constexpr bool is_eq  (weak_equality cmp) noexcept    { return cmp == 0; }
  constexpr bool is_neq (weak_equality cmp) noexcept    { return cmp != 0; }
  constexpr bool is_lt  (partial_ordering cmp) noexcept { return cmp < 0; }
  constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
  constexpr bool is_gt  (partial_ordering cmp) noexcept { return cmp > 0; }
  constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }

  // \ref{cmp.common}, common comparison category type
  template<class... Ts>
  struct common_comparison_category {
    using type = @\seebelow@;
  };
  template<class... Ts>
    using common_comparison_category_t = typename common_comparison_category<Ts...>::type;

  // \ref{cmp.alg}, comparison algorithms
  template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
  template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
  template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
  template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
  template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
}
\end{codeblock}

\rSec2[cmp.categories]{Comparison category types}

\rSec3[cmp.categories.pre]{Preamble}

\pnum
The types
\tcode{weak_equality},
\tcode{strong_equality},
\tcode{partial_ordering},
\tcode{weak_ordering}, and
\tcode{strong_ordering}
are collectively termed the \defn{comparison category types}.
Each is specified in terms of an exposition-only data member named \tcode{value}
whose value typically corresponds to that of an enumerator
from one of the following exposition-only enumerations:

\begin{codeblock}
enum class eq { equal = 0, equivalent = equal,
                nonequal = 1, nonequivalent = nonequal };   // \expos
enum class ord { less = -1, greater = 1 };                  // \expos
enum class ncmp { unordered = -127 };                       // \expos
\end{codeblock}

\pnum
\begin{note}
The types \tcode{strong_ordering} and \tcode{weak_equality}
correspond, respectively, to the terms
total ordering and equivalence in mathematics.
\end{note}

\pnum
The relational and equality operators for the comparison category types
are specified with an anonymous parameter of unspecified type.
This type shall be selected by the implementation such that
these parameters can accept literal \tcode{0} as a corresponding argument.
\begin{example}
\tcode{nullptr_t}
satisfies this requirement.
\end{example}
In this context, the behavior of a program that supplies
an argument other than a literal \tcode{0} is undefined.

\pnum
For the purposes of this subclause,
\defn{substitutability} is the property that \tcode{f(a) == f(b)} is \tcode{true}
whenever \tcode{a == b} is true,
where \tcode{f} denotes a function that reads only comparison-salient state
that is accessible via the argument's public const members.

\rSec3[cmp.weakeq]{Class \tcode{weak_equality}}

\pnum
The \tcode{weak_equality} type is typically used
as the result type of a three-way comparison operator\iref{expr.spaceship}
that (a) admits only equality and inequality comparisons,
and (b) does not imply substitutability.

\indexlibrary{\idxcode{weak_equality}}%
\indexlibrarymember{equivalent}{weak_equality}%
\indexlibrarymember{nonequivalent}{weak_equality}%
\begin{codeblock}
namespace std {
  class weak_equality {
    int value;  // \expos

    // exposition-only constructor
    constexpr explicit weak_equality(eq v) noexcept : value(int(v)) {}  // \expos

  public:
    // valid values
    static const weak_equality equivalent;
    static const weak_equality nonequivalent;

    // comparisons
    friend constexpr bool operator==(weak_equality v, @\unspec@) noexcept;
    friend constexpr bool operator!=(weak_equality v, @\unspec@) noexcept;
    friend constexpr bool operator==(@\unspec@, weak_equality v) noexcept;
    friend constexpr bool operator!=(@\unspec@, weak_equality v) noexcept;
    friend constexpr weak_equality operator<=>(weak_equality v, @\unspec@) noexcept;
    friend constexpr weak_equality operator<=>(@\unspec@, weak_equality v) noexcept;
  };

  // valid values' definitions
  inline constexpr weak_equality weak_equality::equivalent(eq::equivalent);
  inline constexpr weak_equality weak_equality::nonequivalent(eq::nonequivalent);
}
\end{codeblock}

\indexlibrarymember{operator==}{weak_equality}%
\begin{itemdecl}
constexpr bool operator==(weak_equality v, @\unspec@) noexcept;
constexpr bool operator==(@\unspec@, weak_equality v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v.value == 0}.
\end{itemdescr}

\indexlibrarymember{operator"!=}{weak_equality}%
\begin{itemdecl}
constexpr bool operator!=(weak_equality v, @\unspec@) noexcept;
constexpr bool operator!=(@\unspec@, weak_equality v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v.value != 0}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{weak_equality}%
\begin{itemdecl}
constexpr weak_equality operator<=>(weak_equality v, @\unspec@) noexcept;
constexpr weak_equality operator<=>(@\unspec@, weak_equality v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v}.
\end{itemdescr}

\rSec3[cmp.strongeq]{Class \tcode{strong_equality}}

\pnum
The \tcode{strong_equality} type is typically used
as the result type of a three-way comparison operator\iref{expr.spaceship}
that (a) admits only equality and inequality comparisons,
and (b) does imply substitutability.

\indexlibrary{\idxcode{strong_equality}}%
\indexlibrarymember{equal}{strong_equality}%
\indexlibrarymember{nonequal}{strong_equality}%
\indexlibrarymember{equivalent}{strong_equality}%
\indexlibrarymember{nonequivalent}{strong_equality}%
\begin{codeblock}
namespace std {
  class strong_equality {
    int value;  // \expos

    // exposition-only constructor
    constexpr explicit strong_equality(eq v) noexcept : value(int(v)) {}    // \expos

  public:
    // valid values
    static const strong_equality equal;
    static const strong_equality nonequal;
    static const strong_equality equivalent;
    static const strong_equality nonequivalent;

    // conversion
    constexpr operator weak_equality() const noexcept;

    // comparisons
    friend constexpr bool operator==(strong_equality v, @\unspec@) noexcept;
    friend constexpr bool operator!=(strong_equality v, @\unspec@) noexcept;
    friend constexpr bool operator==(@\unspec@, strong_equality v) noexcept;
    friend constexpr bool operator!=(@\unspec@, strong_equality v) noexcept;
    friend constexpr strong_equality operator<=>(strong_equality v, @\unspec@) noexcept;
    friend constexpr strong_equality operator<=>(@\unspec@, strong_equality v) noexcept;
  };

  // valid values' definitions
  inline constexpr strong_equality strong_equality::equal(eq::equal);
  inline constexpr strong_equality strong_equality::nonequal(eq::nonequal);
  inline constexpr strong_equality strong_equality::equivalent(eq::equivalent);
  inline constexpr strong_equality strong_equality::nonequivalent(eq::nonequivalent);
}
\end{codeblock}

\indexlibrarymember{operator weak_equality}{strong_equality}%
\begin{itemdecl}
constexpr operator weak_equality() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{value == 0 ?\ weak_equality::equivalent :\ weak_equality::nonequivalent}.
\end{itemdescr}

\indexlibrarymember{operator==}{strong_equality}%
\begin{itemdecl}
constexpr bool operator==(strong_equality v, @\unspec@) noexcept;
constexpr bool operator==(@\unspec@, strong_equality v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v.value == 0}.
\end{itemdescr}

\indexlibrarymember{operator"!=}{strong_equality}%
\begin{itemdecl}
constexpr bool operator!=(strong_equality v, @\unspec@) noexcept;
constexpr bool operator!=(@\unspec@, strong_equality v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v.value != 0}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{strong_equality}%
\begin{itemdecl}
constexpr strong_equality operator<=>(strong_equality v, @\unspec@) noexcept;
constexpr strong_equality operator<=>(@\unspec@, strong_equality v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v}.
\end{itemdescr}

\rSec3[cmp.partialord]{Class \tcode{partial_ordering}}

\pnum
The \tcode{partial_ordering} type is typically used
as the result type of a three-way comparison operator\iref{expr.spaceship}
that (a) admits all of the six two-way comparison operators (\ref{expr.rel}, \ref{expr.eq}),
(b) does not imply substitutability,
and (c) permits two values to be incomparable.%
\footnote{That is, \tcode{a < b}, \tcode{a == b}, and \tcode{a > b} might all be \tcode{false}.}

\indexlibrary{\idxcode{partial_ordering}}%
\indexlibrarymember{less}{partial_ordering}%
\indexlibrarymember{equivalent}{partial_ordering}%
\indexlibrarymember{greater}{partial_ordering}%
\indexlibrarymember{unordered}{partial_ordering}%
\begin{codeblock}
namespace std {
  class partial_ordering {
    int value;          // \expos
    bool is_ordered;    // \expos

    // exposition-only constructors
    constexpr explicit
      partial_ordering(eq v) noexcept : value(int(v)), is_ordered(true) {}      // \expos
    constexpr explicit
      partial_ordering(ord v) noexcept : value(int(v)), is_ordered(true) {}     // \expos
    constexpr explicit
      partial_ordering(ncmp v) noexcept : value(int(v)), is_ordered(false) {}   // \expos

  public:
    // valid values
    static const partial_ordering less;
    static const partial_ordering equivalent;
    static const partial_ordering greater;
    static const partial_ordering unordered;

    // conversion
    constexpr operator weak_equality() const noexcept;

    // comparisons
    friend constexpr bool operator==(partial_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator!=(partial_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator< (partial_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator> (partial_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator<=(partial_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator>=(partial_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator==(@\unspec@, partial_ordering v) noexcept;
    friend constexpr bool operator!=(@\unspec@, partial_ordering v) noexcept;
    friend constexpr bool operator< (@\unspec@, partial_ordering v) noexcept;
    friend constexpr bool operator> (@\unspec@, partial_ordering v) noexcept;
    friend constexpr bool operator<=(@\unspec@, partial_ordering v) noexcept;
    friend constexpr bool operator>=(@\unspec@, partial_ordering v) noexcept;
    friend constexpr partial_ordering operator<=>(partial_ordering v, @\unspec@) noexcept;
    friend constexpr partial_ordering operator<=>(@\unspec@, partial_ordering v) noexcept;
  };

  // valid values' definitions
  inline constexpr partial_ordering partial_ordering::less(ord::less);
  inline constexpr partial_ordering partial_ordering::equivalent(eq::equivalent);
  inline constexpr partial_ordering partial_ordering::greater(ord::greater);
  inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
}
\end{codeblock}

\indexlibrarymember{operator weak_equality}{partial_ordering}%
\begin{itemdecl}
constexpr operator weak_equality() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{value == 0 ?\ weak_equality::equivalent :\ weak_equality::nonequivalent}.
\begin{note}
The result is independent of the \tcode{is_ordered} member.
\end{note}
\end{itemdescr}

\indexlibrarymember{operator==}{partial_ordering}%
\indexlibrarymember{operator<}{partial_ordering}%
\indexlibrarymember{operator>}{partial_ordering}%
\indexlibrarymember{operator<=}{partial_ordering}%
\indexlibrarymember{operator>=}{partial_ordering}%
\begin{itemdecl}
constexpr bool operator==(partial_ordering v, @\unspec@) noexcept;
constexpr bool operator< (partial_ordering v, @\unspec@) noexcept;
constexpr bool operator> (partial_ordering v, @\unspec@) noexcept;
constexpr bool operator<=(partial_ordering v, @\unspec@) noexcept;
constexpr bool operator>=(partial_ordering v, @\unspec@) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
For \tcode{operator@}, \tcode{v.is_ordered \&\& v.value @ 0}.
\end{itemdescr}

\indexlibrarymember{operator==}{partial_ordering}%
\indexlibrarymember{operator<}{partial_ordering}%
\indexlibrarymember{operator>}{partial_ordering}%
\indexlibrarymember{operator<=}{partial_ordering}%
\indexlibrarymember{operator>=}{partial_ordering}%
\begin{itemdecl}
constexpr bool operator==(@\unspec@, partial_ordering v) noexcept;
constexpr bool operator< (@\unspec@, partial_ordering v) noexcept;
constexpr bool operator> (@\unspec@, partial_ordering v) noexcept;
constexpr bool operator<=(@\unspec@, partial_ordering v) noexcept;
constexpr bool operator>=(@\unspec@, partial_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
For \tcode{operator@}, \tcode{v.is_ordered \&\& 0 @ v.value}.
\end{itemdescr}

\indexlibrarymember{operator"!=}{partial_ordering}%
\begin{itemdecl}
constexpr bool operator!=(partial_ordering v, @\unspec@) noexcept;
constexpr bool operator!=(@\unspec@, partial_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
For \tcode{operator@}, \tcode{!v.is_ordered || v.value != 0}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{partial_ordering}%
\begin{itemdecl}
constexpr partial_ordering operator<=>(partial_ordering v, @\unspec@) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{partial_ordering}%
\begin{itemdecl}
constexpr partial_ordering operator<=>(@\unspec@, partial_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v < 0 ?\ partial_ordering::greater :\ v > 0 ?\ partial_ordering::less :\ v}.
\end{itemdescr}

\rSec3[cmp.weakord]{Class \tcode{weak_ordering}}

\pnum
The \tcode{weak_ordering} type is typically used
as the result type of a three-way comparison operator\iref{expr.spaceship}
that (a) admits all of the six two-way comparison operators (\ref{expr.rel}, \ref{expr.eq}),
and (b) does not imply substitutability.

\indexlibrary{\idxcode{weak_ordering}}%
\indexlibrarymember{less}{weak_ordering}%
\indexlibrarymember{equivalent}{weak_ordering}%
\indexlibrarymember{greater}{weak_ordering}%
\begin{codeblock}
namespace std {
  class weak_ordering {
    int value;  // \expos

    // exposition-only constructors
    constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {}  // \expos
    constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // \expos

  public:
    // valid values
    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

    // conversions
    constexpr operator weak_equality() const noexcept;
    constexpr operator partial_ordering() const noexcept;

    // comparisons
    friend constexpr bool operator==(weak_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator!=(weak_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator< (weak_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator> (weak_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator<=(weak_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator>=(weak_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator==(@\unspec@, weak_ordering v) noexcept;
    friend constexpr bool operator!=(@\unspec@, weak_ordering v) noexcept;
    friend constexpr bool operator< (@\unspec@, weak_ordering v) noexcept;
    friend constexpr bool operator> (@\unspec@, weak_ordering v) noexcept;
    friend constexpr bool operator<=(@\unspec@, weak_ordering v) noexcept;
    friend constexpr bool operator>=(@\unspec@, weak_ordering v) noexcept;
    friend constexpr weak_ordering operator<=>(weak_ordering v, @\unspec@) noexcept;
    friend constexpr weak_ordering operator<=>(@\unspec@, weak_ordering v) noexcept;
  };

  // valid values' definitions
  inline constexpr weak_ordering weak_ordering::less(ord::less);
  inline constexpr weak_ordering weak_ordering::equivalent(eq::equivalent);
  inline constexpr weak_ordering weak_ordering::greater(ord::greater);
}
\end{codeblock}

\indexlibrarymember{operator weak_equality}{weak_ordering}%
\begin{itemdecl}
constexpr operator weak_equality() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{value == 0 ?\ weak_equality::equivalent :\ weak_equality::nonequivalent}.
\end{itemdescr}

\indexlibrarymember{operator partial_ordering}{weak_ordering}%
\begin{itemdecl}
constexpr operator partial_ordering() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\begin{codeblock}
value == 0 ? partial_ordering::equivalent :
value < 0  ? partial_ordering::less :
             partial_ordering::greater
\end{codeblock}
\end{itemdescr}

\indexlibrarymember{operator==}{weak_ordering}%
\indexlibrarymember{operator"!=}{weak_ordering}%
\indexlibrarymember{operator<}{weak_ordering}%
\indexlibrarymember{operator>}{weak_ordering}%
\indexlibrarymember{operator<=}{weak_ordering}%
\indexlibrarymember{operator>=}{weak_ordering}%
\begin{itemdecl}
constexpr bool operator==(weak_ordering v, @\unspec@) noexcept;
constexpr bool operator!=(weak_ordering v, @\unspec@) noexcept;
constexpr bool operator< (weak_ordering v, @\unspec@) noexcept;
constexpr bool operator> (weak_ordering v, @\unspec@) noexcept;
constexpr bool operator<=(weak_ordering v, @\unspec@) noexcept;
constexpr bool operator>=(weak_ordering v, @\unspec@) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v.value @ 0} for \tcode{operator@}.
\end{itemdescr}

\indexlibrarymember{operator==}{weak_ordering}%
\indexlibrarymember{operator"!=}{weak_ordering}%
\indexlibrarymember{operator<}{weak_ordering}%
\indexlibrarymember{operator>}{weak_ordering}%
\indexlibrarymember{operator<=}{weak_ordering}%
\indexlibrarymember{operator>=}{weak_ordering}%
\begin{itemdecl}
constexpr bool operator==(@\unspec@, weak_ordering v) noexcept;
constexpr bool operator!=(@\unspec@, weak_ordering v) noexcept;
constexpr bool operator< (@\unspec@, weak_ordering v) noexcept;
constexpr bool operator> (@\unspec@, weak_ordering v) noexcept;
constexpr bool operator<=(@\unspec@, weak_ordering v) noexcept;
constexpr bool operator>=(@\unspec@, weak_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{0 @ v.value} for \tcode{operator@}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{weak_ordering}%
\begin{itemdecl}
constexpr weak_ordering operator<=>(weak_ordering v, @\unspec@) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{weak_ordering}%
\begin{itemdecl}
constexpr weak_ordering operator<=>(@\unspec@, weak_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v < 0 ?\ weak_ordering::greater :\ v > 0 ?\ weak_ordering::less :\ v}.
\end{itemdescr}

\rSec3[cmp.strongord]{Class \tcode{strong_ordering}}

\pnum
The \tcode{strong_ordering} type is typically used
as the result type of a three-way comparison operator\iref{expr.spaceship}
that (a) admits all of the six two-way comparison operators (\ref{expr.rel}, \ref{expr.eq}),
and (b) does imply substitutability.

\indexlibrary{\idxcode{strong_ordering}}%
\indexlibrarymember{less}{strong_ordering}%
\indexlibrarymember{equal}{strong_ordering}%
\indexlibrarymember{equivalent}{strong_ordering}%
\indexlibrarymember{greater}{strong_ordering}%
\begin{codeblock}
namespace std {
  class strong_ordering {
    int value;  // \expos

    // exposition-only constructors
    constexpr explicit strong_ordering(eq v) noexcept : value(int(v)) {}    // \expos
    constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {}   // \expos

  public:
    // valid values
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;

    // conversions
    constexpr operator weak_equality() const noexcept;
    constexpr operator strong_equality() const noexcept;
    constexpr operator partial_ordering() const noexcept;
    constexpr operator weak_ordering() const noexcept;

    // comparisons
    friend constexpr bool operator==(strong_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator!=(strong_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator< (strong_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator> (strong_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator<=(strong_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator>=(strong_ordering v, @\unspec@) noexcept;
    friend constexpr bool operator==(@\unspec@, strong_ordering v) noexcept;
    friend constexpr bool operator!=(@\unspec@, strong_ordering v) noexcept;
    friend constexpr bool operator< (@\unspec@, strong_ordering v) noexcept;
    friend constexpr bool operator> (@\unspec@, strong_ordering v) noexcept;
    friend constexpr bool operator<=(@\unspec@, strong_ordering v) noexcept;
    friend constexpr bool operator>=(@\unspec@, strong_ordering v) noexcept;
    friend constexpr strong_ordering operator<=>(strong_ordering v, @\unspec@) noexcept;
    friend constexpr strong_ordering operator<=>(@\unspec@, strong_ordering v) noexcept;
  };

  // valid values' definitions
  inline constexpr strong_ordering strong_ordering::less(ord::less);
  inline constexpr strong_ordering strong_ordering::equal(eq::equal);
  inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent);
  inline constexpr strong_ordering strong_ordering::greater(ord::greater);
}
\end{codeblock}

\indexlibrarymember{operator weak_equality}{strong_ordering}%
\begin{itemdecl}
constexpr operator weak_equality() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{value == 0 ?\ weak_equality::equivalent :\ weak_equality::nonequivalent}.
\end{itemdescr}

\indexlibrarymember{operator strong_equality}{strong_ordering}%
\begin{itemdecl}
constexpr operator strong_equality() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{value == 0 ?\ strong_equality::equal :\ strong_equality::nonequal}.
\end{itemdescr}

\indexlibrarymember{operator partial_ordering}{strong_ordering}%
\begin{itemdecl}
constexpr operator partial_ordering() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\begin{codeblock}
value == 0 ? partial_ordering::equivalent :
value < 0  ? partial_ordering::less :
             partial_ordering::greater
\end{codeblock}
\end{itemdescr}

\indexlibrarymember{operator weak_ordering}{strong_ordering}%
\begin{itemdecl}
constexpr operator weak_ordering() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\begin{codeblock}
value == 0 ? weak_ordering::equivalent :
value < 0  ? weak_ordering::less :
             weak_ordering::greater
\end{codeblock}
\end{itemdescr}

\indexlibrarymember{operator==}{strong_ordering}%
\indexlibrarymember{operator"!=}{strong_ordering}%
\indexlibrarymember{operator<}{strong_ordering}%
\indexlibrarymember{operator>}{strong_ordering}%
\indexlibrarymember{operator<=}{strong_ordering}%
\indexlibrarymember{operator>=}{strong_ordering}%
\begin{itemdecl}
constexpr bool operator==(strong_ordering v, @\unspec@) noexcept;
constexpr bool operator!=(strong_ordering v, @\unspec@) noexcept;
constexpr bool operator< (strong_ordering v, @\unspec@) noexcept;
constexpr bool operator> (strong_ordering v, @\unspec@) noexcept;
constexpr bool operator<=(strong_ordering v, @\unspec@) noexcept;
constexpr bool operator>=(strong_ordering v, @\unspec@) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v.value @ 0} for \tcode{operator@}.
\end{itemdescr}

\indexlibrarymember{operator==}{strong_ordering}%
\indexlibrarymember{operator"!=}{strong_ordering}%
\indexlibrarymember{operator<}{strong_ordering}%
\indexlibrarymember{operator>}{strong_ordering}%
\indexlibrarymember{operator<=}{strong_ordering}%
\indexlibrarymember{operator>=}{strong_ordering}%
\begin{itemdecl}
constexpr bool operator==(@\unspec@, strong_ordering v) noexcept;
constexpr bool operator!=(@\unspec@, strong_ordering v) noexcept;
constexpr bool operator< (@\unspec@, strong_ordering v) noexcept;
constexpr bool operator> (@\unspec@, strong_ordering v) noexcept;
constexpr bool operator<=(@\unspec@, strong_ordering v) noexcept;
constexpr bool operator>=(@\unspec@, strong_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{0 @ v.value} for \tcode{operator@}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{strong_ordering}%
\begin{itemdecl}
constexpr strong_ordering operator<=>(strong_ordering v, @\unspec@) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v}.
\end{itemdescr}

\indexlibrarymember{operator<=>}{strong_ordering}%
\begin{itemdecl}
constexpr strong_ordering operator<=>(@\unspec@, strong_ordering v) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns
\tcode{v < 0 ?\ strong_ordering::greater :\ v > 0 ?\ strong_ordering::less :\ v}.
\end{itemdescr}

\rSec2[cmp.common]{Class template \tcode{common_comparison_category}}

\pnum
The type \tcode{common_comparison_category} provides an alias for
the strongest comparison category
to which all of the template arguments can be converted.
\begin{note}
A comparison category type is stronger than another if
they are distinct types and an instance of the former
can be converted to an instance of the latter.
\end{note}

\indexlibrary{\idxcode{common_comparison_category}}%
\begin{itemdecl}
template<class... Ts>
struct common_comparison_category {
  using type = @\seebelow@;
};
\end{itemdecl}

\begin{itemdescr}
\pnum
\remarks
The member \grammarterm{typedef-name} \tcode{type} denotes
the common comparison type\iref{class.spaceship} of \tcode{Ts...},
the expanded parameter pack.
\begin{note}
This is well-defined even if
the expansion is empty or
includes a type that is not a comparison category type.
\end{note}
\end{itemdescr}

\rSec2[cmp.alg]{Comparison algorithms}

\indexlibrary{\idxcode{strong_order}}%
\begin{itemdecl}
template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares two values and produces a result of type \tcode{strong_ordering}:

\begin{itemize}
\item
If \tcode{numeric_limits<T>::is_iec559} is \tcode{true},
returns a result of type \tcode{strong_ordering}
that is consistent with the \tcode{totalOrder} operation
as specified in ISO/IEC/IEEE 60559.
\item
Otherwise, returns \tcode{a <=> b}
if that expression is well-formed and
convertible to \tcode{strong_ordering}.
\item
Otherwise, if the expression \tcode{a <=> b} is well-formed,
then the function is defined as deleted.
\item
Otherwise, if the expressions \tcode{a == b} and \tcode{a < b}
are each well-formed and convertible to \tcode{bool}, then
\begin{itemize}
\item
if \tcode{a == b} is \tcode{true},
returns \tcode{strong_ordering::equal};
\item
otherwise, if \tcode{a < b} is \tcode{true},
returns \tcode{strong_ordering::less};
\item
otherwise,
returns \tcode{strong_ordering::greater}.
\end{itemize}
\item
Otherwise, the function is defined as deleted.
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{weak_order}}%
\begin{itemdecl}
template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares two values and produces a result of type \tcode{weak_ordering}:

\begin{itemize}
\item
Returns \tcode{a <=> b} if that expression is well-formed and
convertible to \tcode{weak_ordering}.
\item
Otherwise, if the expression \tcode{a <=> b} is well-formed,
then the function is defined as deleted.
\item
Otherwise, if the expressions \tcode{a == b} and \tcode{a < b}
are each well-formed and convertible to \tcode{bool}, then
\begin{itemize}
\item
if \tcode{a == b} is \tcode{true},
returns \tcode{weak_ordering::equivalent};
\item
otherwise, if \tcode{a < b} is \tcode{true},
returns \tcode{weak_ordering::less};
\item
otherwise, returns \tcode{weak_ordering::greater}.
\end{itemize}
\item
Otherwise, the function is defined as deleted.
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{partial_order}}%
\begin{itemdecl}
template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares two values and produces a result of type \tcode{partial_ordering}:

\begin{itemize}
\item
Returns \tcode{a <=> b} if that expression is well-formed and
convertible to \tcode{partial_ordering}.
\item
Otherwise, if the expression \tcode{a <=> b} is well-formed,
then the function is defined as deleted.
\item
Otherwise, if the expressions \tcode{a == b} and \tcode{a < b}
are each well-formed and convertible to \tcode{bool}, then
\begin{itemize}
\item
if \tcode{a == b} is \tcode{true},
returns \tcode{partial_ordering::equivalent};
\item
otherwise, if \tcode{a < b} is \tcode{true},
returns \tcode{partial_ordering::less};
\item
otherwise, returns \tcode{partial_ordering::greater}.
\end{itemize}
\item
Otherwise, the function is defined as deleted.
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{strong_equal}}%
\begin{itemdecl}
template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares two values and produces a result of type \tcode{strong_equality}:

\begin{itemize}
\item
Returns \tcode{a <=> b} if that expression is well-formed and
convertible to \tcode{strong_equality}.
\item
Otherwise, if the expression \tcode{a <=> b} is well-formed,
then the function is defined as deleted.
\item
Otherwise, if the expression \tcode{a == b}
is well-formed and convertible to \tcode{bool}, then
\begin{itemize}
\item
if \tcode{a == b} is \tcode{true},
returns \tcode{strong_equality::equal};
\item
otherwise, returns \tcode{strong_equality::nonequal}.
\end{itemize}
\item
Otherwise, the function is defined as deleted.
\end{itemize}
\end{itemdescr}

\indexlibrary{\idxcode{weak_equal}}%
\begin{itemdecl}
template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
\end{itemdecl}

\begin{itemdescr}
\pnum
\effects
Compares two values and produces a result of type \tcode{weak_equality}:

\begin{itemize}
\item
Returns \tcode{a <=> b} if that expression is well-formed and
convertible to \tcode{weak_equality}.
\item
Otherwise, if the expression \tcode{a <=> b} is well-formed,
then the function is defined as deleted.
\item
Otherwise, if the expression \tcode{a == b}
is well-formed and convertible to \tcode{bool}, then
\begin{itemize}
\item
if \tcode{a == b} is \tcode{true},
returns \tcode{weak_equality::equivalent};
\item
otherwise, returns \tcode{weak_equality::nonequivalent}.
\end{itemize}
\item
Otherwise, the function is defined as deleted.
\end{itemize}
\end{itemdescr}

\rSec1[support.coroutine]{Coroutines}

\pnum
The header
\tcode{<coroutine>}
defines several types providing
compile and run-time support for
coroutines in a \Cpp{} program.

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

\indextext{\idxhdr{coroutine}}%
\indexlibrary{\idxhdr{coroutine}}%
\indexlibrary{\idxcode{noop_coroutine_handle}}%
\begin{codeblock}
namespace std {
  // \ref{coroutine.traits}, coroutine traits
  template<class R, class... ArgTypes>
    struct coroutine_traits;

  // \ref{coroutine.handle}, coroutine handle
  template<class Promise = void>
    struct coroutine_handle;

  // \ref{coroutine.handle.compare}, comparison operators
  constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
  constexpr bool operator!=(coroutine_handle<> x, coroutine_handle<> y) noexcept;
  constexpr bool operator<(coroutine_handle<> x, coroutine_handle<> y) noexcept;
  constexpr bool operator>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
  constexpr bool operator<=(coroutine_handle<> x, coroutine_handle<> y) noexcept;
  constexpr bool operator>=(coroutine_handle<> x, coroutine_handle<> y) noexcept;

  // \ref{coroutine.handle.hash}, hash support
  template<class T> struct hash;
  template<class P> struct hash<coroutine_handle<P>>;

  // \ref{coroutine.noop}, no-op coroutines
  struct noop_coroutine_promise;

  template<> struct coroutine_handle<noop_coroutine_promise>;
  using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;

  noop_coroutine_handle noop_coroutine() noexcept;

  // \ref{coroutine.trivial.awaitables}, trivial awaitables
  struct suspend_never;
  struct suspend_always;
}
\end{codeblock}

\rSec2[coroutine.traits]{Coroutine traits}

\pnum
This subclause defines requirements on classes representing
\term{coroutine traits},
and defines the class template
\tcode{coroutine_traits}
that satisfies those requirements.

\rSec3[coroutine.traits.primary]{Class template \tcode{coroutine_traits}}

\pnum
The header \tcode{<coroutine>} defines the primary template
\tcode{coroutine_traits} such that
if \tcode{ArgTypes} is a parameter pack of types and
if the \grammarterm{qualified-id} \tcode{R::promise_type} is valid and
denotes a type\iref{temp.deduct},
then \tcode{coroutine_traits<R,ArgTypes...>} has the following publicly
accessible member:

\begin{codeblock}
  using promise_type = typename R::promise_type;
\end{codeblock}

Otherwise, \tcode{coroutine_traits<R,ArgTypes...>} has no members.

\pnum
Program defined specializations of this template shall define a publicly
accessible nested type named \tcode{promise_type}.

\rSec2[coroutine.handle]{Class template \tcode{coroutine_handle}}

\indexlibrary{\idxcode{coroutine_handle}}%
\begin{codeblock}
namespace std {
  template<>
  struct coroutine_handle<void>
  {
    // \ref{coroutine.handle.con}, construct/reset
    constexpr coroutine_handle() noexcept;
    constexpr coroutine_handle(nullptr_t) noexcept;
    coroutine_handle& operator=(nullptr_t) noexcept;

    // \ref{coroutine.handle.export.import}, export/import
    constexpr void* address() const noexcept;
    constexpr static coroutine_handle from_address(void* addr);

    // \ref{coroutine.handle.observers}, observers
    constexpr explicit operator bool() const noexcept;
    bool done() const;

    // \ref{coroutine.handle.resumption}, resumption
    void operator()() const;
    void resume() const;
    void destroy() const;

  private:
    void* ptr;  // \expos
  };

  template<class Promise>
  struct coroutine_handle : coroutine_handle<>
  {
    // \ref{coroutine.handle.con}, construct/reset
    using coroutine_handle<>::coroutine_handle;
    static coroutine_handle from_promise(Promise&);
    coroutine_handle& operator=(nullptr_t) noexcept;

    // \ref{coroutine.handle.export.import}, export/import
    constexpr static coroutine_handle from_address(void* addr);

    // \ref{coroutine.handle.promise}, promise access
    Promise& promise() const;
  };
}
\end{codeblock}

\pnum
An object of type
\tcode{coroutine_handle<T>} is called a \term{coroutine handle}
and can be used to refer to a suspended or executing coroutine.
A default-constructed \tcode{coroutine_handle} object does not refer to any
coroutine.

\pnum
If a program declares an explicit or partial specialization of
\tcode{coroutine_handle}, the behavior is undefined.

\rSec3[coroutine.handle.con]{Construct/reset}

\indexlibrary{\idxcode{coroutine_handle}!constructor}%
\begin{itemdecl}
constexpr coroutine_handle() noexcept;
constexpr coroutine_handle(nullptr_t) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\ensures \tcode{address() == nullptr}.
\end{itemdescr}

\indexlibrarymember{from_promise}{coroutine_handle}%
\begin{itemdecl}
static coroutine_handle from_promise(Promise& p);
\end{itemdecl}

\begin{itemdescr}
\pnum
\requires \tcode{p} is a reference to a promise object of a coroutine.

\pnum
\returns A coroutine handle \tcode{h} referring to the coroutine.

\pnum
\ensures \tcode{addressof(h.promise()) == addressof(p)}.
\end{itemdescr}

\indexlibrarymember{operator=}{coroutine_handle}%
\begin{itemdecl}
coroutine_handle& operator=(nullptr_t) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\ensures \tcode{address() == nullptr}.

\pnum
\returns \tcode{*this}.
\end{itemdescr}

\rSec3[coroutine.handle.export.import]{Export/import}

\indexlibrarymember{address}{coroutine_handle}%
\begin{itemdecl}
constexpr void* address() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns \tcode{ptr}.
\end{itemdescr}

\indexlibrarymember{from_address}{coroutine_handle}%
\begin{itemdecl}
constexpr static coroutine_handle<> coroutine_handle<>::from_address(void* addr);
constexpr static coroutine_handle<Promise> coroutine_handle<Promise>::from_address(void* addr);
\end{itemdecl}

\begin{itemdescr}
\pnum
\requires \tcode{addr} was obtained via a prior call to \tcode{address}.

\pnum
\ensures \tcode{from_address(address()) == *this}.
\end{itemdescr}

\rSec3[coroutine.handle.observers]{Observers}

\indexlibrarymember{operator bool}{coroutine_handle}%
\begin{itemdecl}
constexpr explicit operator bool() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum
\returns \tcode{address() != nullptr}.
\end{itemdescr}

\indexlibrarymember{done}{coroutine_handle}%
\begin{itemdecl}
bool done() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\requires \tcode{*this} refers to a suspended coroutine.

\pnum
\returns \tcode{true} if the coroutine is suspended at its
final suspend point, otherwise \tcode{false}.
\end{itemdescr}

\rSec3[coroutine.handle.resumption]{Resumption}

\pnum
Resuming a coroutine via \tcode{resume}, \tcode{operator()}, or \tcode{destroy}
on an execution agent other than the one on which it was suspended
has implementation-defined behavior unless
each execution agent is either
an instance of \tcode{std::thread} or
the thread that executes \tcode{main}.
\begin{note}
A coroutine that is resumed on a different execution agent should
avoid relying on consistent thread identity throughout, such as holding
a mutex object across a suspend point.
\end{note}
\begin{note}
A concurrent resumption of the coroutine may result in a data race.
\end{note}

\indexlibrarymember{operator()}{coroutine_handle}%
\indexlibrarymember{resume}{coroutine_handle}%
\begin{itemdecl}
void operator()() const;
void resume() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\requires \tcode{*this} refers to a suspended coroutine.

\pnum
\effects Resumes the execution of the coroutine. If the coroutine
was suspended at its final suspend point, behavior is undefined.
\end{itemdescr}

\indexlibrarymember{destroy}{coroutine_handle}%
\begin{itemdecl}
void destroy() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\requires \tcode{*this} refers to a suspended coroutine.

\pnum
\effects Destroys the coroutine\iref{dcl.fct.def.coroutine}.
\end{itemdescr}

\rSec3[coroutine.handle.promise]{Promise access}

\indexlibrarymember{promise}{coroutine_handle}%
\begin{itemdecl}
Promise& promise() const;
\end{itemdecl}

\begin{itemdescr}
\pnum
\requires \tcode{*this} refers to a coroutine.

\pnum
\returns A reference to the promise of the coroutine.
\end{itemdescr}

\rSec3[coroutine.handle.compare]{Comparison operators}

\indexlibrarymember{operator==}{coroutine_handle}%
\indexlibrarymember{operator"!=}{coroutine_handle}%
\begin{itemdecl}
constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns \tcode{x.address() == y.address()}.
\end{itemdescr}

\indexlibrarymember{operator<}{coroutine_handle}%
\indexlibrarymember{operator>}{coroutine_handle}%
\indexlibrarymember{operator<=}{coroutine_handle}%
\indexlibrarymember{operator>=}{coroutine_handle}%
\begin{itemdecl}
constexpr bool operator<(coroutine_handle<> x, coroutine_handle<> y) noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns \tcode{less<>()(x.address(), y.address())}.
\end{itemdescr}

\rSec3[coroutine.handle.hash]{Hash support}

\indexlibrary{\idxcode{hash}!\idxcode{coroutine_handle}}%
\begin{itemdecl}
template<class P> struct hash<coroutine_handle<P>>;
\end{itemdecl}

\begin{itemdescr}
\pnum The specialization is enabled\iref{unord.hash}.
\end{itemdescr}

\rSec2[coroutine.noop]{No-op coroutines}

\rSec3[coroutine.promise.noop]{Class \tcode{noop_coroutine_promise}}

\indexlibrary{\idxcode{noop_coroutine_promise}}%
\begin{itemdecl}
struct noop_coroutine_promise {};
\end{itemdecl}

\begin{itemdescr}
\pnum The class \tcode{noop_coroutine_promise} defines the promise type for
the coroutine referred to
by \tcode{noop_coroutine_handle}\iref{coroutine.syn}.
\end{itemdescr}

\rSec3[coroutine.handle.noop]{Class \tcode{coroutine_handle<noop_coroutine_promise>}}

\indexlibrary{\idxcode{coroutine_handle<noop_coroutine_promise>}}%
\begin{codeblock}
namespace std {
  template<>
  struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
  {
    // \ref{coroutine.handle.noop.observers}, observers
    constexpr explicit operator bool() const noexcept;
    constexpr bool done() const noexcept;

    // \ref{coroutine.handle.noop.resumption}, resumption
    constexpr void operator()() const noexcept;
    constexpr void resume() const noexcept;
    constexpr void destroy() const noexcept;

    // \ref{coroutine.handle.noop.promise}, promise access
    noop_coroutine_promise& promise() const noexcept;

    // \ref{coroutine.handle.noop.address}, address
    constexpr void* address() const noexcept;
  private:
    coroutine_handle(@\unspec@);
  };
}
\end{codeblock}

\rSec4[coroutine.handle.noop.observers]{Observers}

\indexlibrarymember{operator bool}{coroutine_handle<noop_coroutine_promise>}%
\begin{itemdecl}
constexpr explicit operator bool() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns \tcode{true}.
\end{itemdescr}

\indexlibrarymember{done}{coroutine_handle<noop_coroutine_promise>}%
\begin{itemdecl}
constexpr bool done() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns \tcode{false}.
\end{itemdescr}

\rSec4[coroutine.handle.noop.resumption]{Resumption}

\indexlibrarymember{operator()}{coroutine_handle<noop_coroutine_promise>}%
\indexlibrarymember{resume}{coroutine_handle<noop_coroutine_promise>}%
\indexlibrarymember{destroy}{coroutine_handle<noop_coroutine_promise>}%
\begin{itemdecl}
constexpr void operator()() const noexcept;
constexpr void resume() const noexcept;
constexpr void destroy() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \effects None.

\pnum
\remarks
If \tcode{noop_coroutine_handle} is converted to \tcode{coroutine_handle<>},
calls to \tcode{operator()}, \tcode{resume} and \tcode{destroy} on that handle
will also have no observable effects.
\end{itemdescr}

\rSec4[coroutine.handle.noop.promise]{Promise access}

\indexlibrarymember{promise}{coroutine_handle<noop_coroutine_promise>}%
\begin{itemdecl}
noop_coroutine_promise& promise() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns A reference to the promise object associated with this
coroutine handle.
\end{itemdescr}

\rSec4[coroutine.handle.noop.address]{Address}

\indexlibrarymember{address}{coroutine_handle<noop_coroutine_promise>}%
\begin{itemdecl}
constexpr void* address() const noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns \tcode{ptr}.

\pnum \remarks A \tcode{noop_coroutine_handle}'s \tcode{ptr} is always a
non-null pointer value.
\end{itemdescr}

\rSec3[coroutine.noop.coroutine]{Function \tcode{noop_coroutine}}

\indexlibrary{noop_coroutine}%
\begin{itemdecl}
noop_coroutine_handle noop_coroutine() noexcept;
\end{itemdecl}

\begin{itemdescr}
\pnum \returns A handle to a coroutine that has no observable effects
when resumed or destroyed.

\pnum \remarks A handle returned from \tcode{noop_coroutine} may or may not
compare equal to a handle returned from another invocation
of \tcode{noop_coroutine}.
\end{itemdescr}

\rSec2[coroutine.trivial.awaitables]{Trivial awaitables}

\indexlibrary{\idxcode{suspend_never}}%
\indexlibrarymember{await_ready}{suspend_never}%
\indexlibrarymember{await_suspend}{suspend_never}%
\indexlibrarymember{await_resume}{suspend_never}%
\indexlibrary{\idxcode{suspend_always}}%
\indexlibrarymember{await_ready}{suspend_always}%
\indexlibrarymember{await_suspend}{suspend_always}%
\indexlibrarymember{await_resume}{suspend_always}%
\begin{codeblock}
namespace std {
  struct suspend_never {
    constexpr bool await_ready() const noexcept { return true; }
    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
  };
  struct suspend_always {
    constexpr bool await_ready() const noexcept { return false; }
    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
  };
}
\end{codeblock}

\pnum
\begin{note}
The types \tcode{suspend_never} and \tcode{suspend_always} can be used
to indicate that an \grammarterm{await-expression} should either never
suspend or always suspend, and in either case not produce a value.
\end{note}

\rSec1[support.runtime]{Other runtime support}

\pnum
\indexhdr{cstdarg}%
\indexhdr{csetjmp}%
\indexhdr{ctime}%
\indexhdr{csignal}%
\indexhdr{cstdlib}%
\indexlibrary{\idxcode{getenv}}%
\indexlibrary{\idxcode{system}}%
Headers
\tcode{<csetjmp>} (nonlocal jumps),
\tcode{<csignal>} (signal handling),
\tcode{<cstdarg>} (variable arguments),
and
\tcode{<cstdlib>} (runtime environment \tcode{getenv}, \tcode{system}),
provide further compatibility with C code.

\pnum
Calls to the function
\indexlibrary{\idxcode{getenv}}%
\tcode{getenv}\iref{cstdlib.syn} shall not introduce a data
race\iref{res.on.data.races} provided that nothing modifies the environment.
\begin{note} Calls to the POSIX functions
\indexlibrary{\idxcode{setenv}}%
\tcode{setenv} and
\indexlibrary{\idxcode{putenv}}%
\tcode{putenv} modify the
environment. \end{note}

\pnum
A call to the \tcode{setlocale} function\iref{c.locales}
may introduce a data race with other
calls to the \tcode{setlocale} function or with calls to functions that are
affected by the current C locale. The implementation shall behave as if no
library function other than \tcode{locale::global} calls the \tcode{setlocale}
function.

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

\indexhdr{cstdarg}%
\indexlibrary{\idxcode{va_list}}%
\indexlibrary{\idxcode{va_start}}%
\indexlibrary{\idxcode{va_copy}}%
\indexlibrary{\idxcode{va_end}}%
\indexlibrary{\idxcode{va_arg}}%
\begin{codeblock}
namespace std {
  using va_list = @\seebelow@;
}

#define va_arg(V, P) @\seebelow@
#define va_copy(VDST, VSRC) @\seebelow@
#define va_end(V) @\seebelow@
#define va_start(V, P) @\seebelow@
\end{codeblock}

\pnum
\indexhdr{stdarg.h}%
The contents of the header \tcode{<cstdarg>} are the same as the C
standard library header \tcode{<stdarg.h>}, with the following changes:
The restrictions that ISO C places on the second parameter to the
\indexlibrary{\idxcode{va_start}}%
\tcode{va_start}
macro in header
\indexhdr{stdarg.h}%
\tcode{<stdarg.h>}
are different in this document.
The parameter
\tcode{parmN}
is the rightmost parameter in the variable parameter list
of the function definition (the one just before the
\tcode{...}).\footnote{Note that
\tcode{va_start}
is required to work as specified even if unary
\tcode{operator\&}
is overloaded for the type of
\tcode{parmN}.}
If the parameter \tcode{parmN} is a pack expansion\iref{temp.variadic} or
an entity resulting from a lambda capture\iref{expr.prim.lambda},
the program is ill-formed, no diagnostic required.
If the parameter
\tcode{parmN}
is of a reference type, or of a type that is not compatible with the
type that results when passing an argument for which there is no
parameter, the behavior is undefined.

\xrefc{7.16.1.1}

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

\indexhdr{csetjmp}%
\indexlibrary{\idxcode{jmp_buf}}%
\indexlibrary{\idxcode{longjmp}}%
\indexlibrary{\idxcode{setjmp}}%
\begin{codeblock}
namespace std {
  using jmp_buf = @\seebelow@;
  [[noreturn]] void longjmp(jmp_buf env, int val);
}

#define setjmp(env) @\seebelow@
\end{codeblock}

\pnum
\indexhdr{setjmp.h}%
The contents of the header \tcode{<csetjmp>} are the same as the C
standard library header \tcode{<setjmp.h>}.

\pnum
The function signature
\indexlibrary{\idxcode{longjmp}}%
\tcode{longjmp(jmp_buf jbuf, int val)}
has more restricted behavior in this document.
A \tcode{setjmp}/\tcode{longjmp} call pair has undefined
behavior if replacing the \tcode{setjmp} and \tcode{longjmp}
by \tcode{catch} and \tcode{throw} would invoke any non-trivial destructors for any automatic
objects.
A call to \tcode{setjmp} or \tcode{longjmp} has undefined
behavior if invoked in a suspension context of a coroutine\iref{expr.await}.

\xrefc{7.13}

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

\indexhdr{csignal}%
\indexlibrary{\idxcode{sig_atomic_t}}%
\indexlibrary{\idxcode{signal}}%
\indexlibrary{\idxcode{raise}}%
\indexlibrary{\idxcode{SIG_IGN}}%
\indexlibrary{\idxcode{SIGABRT}}%
\indexlibrary{\idxcode{SIGFPE}}%
\indexlibrary{\idxcode{SIGILL}}%
\indexlibrary{\idxcode{SIGINT}}%
\indexlibrary{\idxcode{SIGSEGV}}%
\indexlibrary{\idxcode{SIGTERM}}%
\indexlibrary{\idxcode{SIG_DFL}}%
\indexlibrary{\idxcode{SIG_ERR}}%
\begin{codeblock}
namespace std {
  using sig_atomic_t = @\seebelow@;

  // \ref{support.signal}, signal handlers
  extern "C" using @\placeholdernc{signal-handler}@ = void(int);  // \expos
  @\placeholder{signal-handler}@* signal(int sig, @\placeholder{signal-handler}@* func);

  int raise(int sig);
}

#define SIG_DFL @\seebelow@
#define SIG_ERR @\seebelow@
#define SIG_IGN @\seebelow@
#define SIGABRT @\seebelow@
#define SIGFPE @\seebelow@
#define SIGILL @\seebelow@
#define SIGINT @\seebelow@
#define SIGSEGV @\seebelow@
#define SIGTERM @\seebelow@
\end{codeblock}

\pnum
\indexhdr{signal.h}%
The contents of the header \tcode{<csignal>} are the same as the C
standard library header \tcode{<signal.h>}.

\rSec2[support.signal]{Signal handlers}

\pnum
A call to the function \tcode{signal} synchronizes with any resulting
invocation of the signal handler so installed.

\pnum
A \defn{plain lock-free atomic operation} is
an invocation of a function \tcode{f} from \ref{atomics},
such that:

\begin{itemize}
\item
\tcode{f} is the function \tcode{atomic_is_lock_free()}, or

\item
\tcode{f} is the member function \tcode{is_lock_free()}, or

\item
\tcode{f} is a non-static member function invoked on an object \tcode{A},
such that \tcode{A.is_lock_free()} yields \tcode{true}, or

\item
\tcode{f} is a non-member function, and
for every pointer-to-atomic argument \tcode{A} passed to \tcode{f},
\tcode{atomic_is_lock_free(A)} yields \tcode{true}.
\end{itemize}

\pnum
\indextext{signal-safe!evaluation|see{evaluation, signal-safe}}%
An evaluation is \defnx{signal-safe}{evaluation!signal-safe} unless it includes one of the following:

\begin{itemize}
\item
a call to any standard library function,
except for plain lock-free atomic operations and
functions explicitly identified as signal-safe.
\begin{note}
This implicitly excludes the use of \tcode{new} and \tcode{delete} expressions
that rely on a library-provided memory allocator.
\end{note}

\item
an access to an object with thread storage duration;

\item
a \tcode{dynamic_cast} expression;

\item
throwing of an exception;

\item
control entering a \grammarterm{try-block} or \grammarterm{function-try-block};

\item
initialization of a variable with static storage duration
requiring dynamic initialization~(\ref{basic.start.dynamic}, \ref{stmt.dcl})%
\footnote{Such initialization might occur because it is the first odr-use\iref{basic.def.odr} of that variable.}; or

\item
waiting for the completion of the initialization of a variable with static storage duration\iref{stmt.dcl}.
\end{itemize}

A signal handler invocation has undefined behavior if it includes
an evaluation that is not signal-safe.

\pnum
\indextext{signal-safe!\idxcode{signal}}%
The function \tcode{signal} is signal-safe if it is invoked
with the first argument equal to the signal number
corresponding to the signal that caused the invocation of the handler.

\xrefc{7.14}