17 Language support library [support]

17.1 General [support.general]

1
#
This Clause describes the function signatures that are called implicitly, and the types of objects generated implicitly, during the execution of some C++ programs.
It also describes the headers that declare these function signatures and define any related types.
2
#
The following subclauses describe common type definitions used throughout the library, characteristics of the predefined types, functions supporting start and termination of a C++ program, support for dynamic memory management, support for dynamic type identification, support for exception processing, support for initializer lists, and other runtime support, as summarized in Table 37.
Table 37: Language support library summary   [tab:support.summary]
Subclause
Header
Common definitions
<cstddef>, <cstdlib>
Implementation properties
<cfloat>, <climits>, <limits>, <version>
Integer types
<cstdint>
Start and termination
<cstdlib>
Dynamic memory management
<new>
Type identification
<typeinfo>
Source location
<source_­location>
Exception handling
<exception>
Initializer lists
<initializer_­list>
Comparisons
<compare>
Coroutines
<coroutine>
Other runtime support
<csetjmp>, <csignal>, <cstdarg>, <cstdlib>

17.2 Common definitions [support.types]

17.2.1 Header <cstddef> synopsis [cstddef.syn]

namespace std {
  using ptrdiff_­t = see below;
  using size_­t = see below;
  using max_­align_­t = see below;
  using nullptr_­t = decltype(nullptr);

  enum class byte : unsigned char {};

  // [support.types.byteops], 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 see below
#define offsetof(P, D) see below
1
#
The contents and meaning of the header <cstddef> are the same as the C standard library header <stddef.h>, except that it does not declare the type wchar_­t, that it also declares the type byte and its associated operations ([support.types.byteops]), and as noted in [support.types.nullptr] and [support.types.layout].
See also: ISO C 7.19

17.2.2 Header <cstdlib> synopsis [cstdlib.syn]

namespace std {
  using size_t = see below;
  using div_t = see below;
  using ldiv_t = see below;
  using lldiv_t = see below;
}

#define NULL see below
#define EXIT_FAILURE see below
#define EXIT_SUCCESS see below
#define RAND_MAX see below
#define MB_CUR_MAX see below

namespace std {
  // Exposition-only function type aliases
  extern "C" using c-atexit-handler = void();                        // exposition only
  extern "C++" using atexit-handler = void();                        // exposition only
  extern "C" using c-compare-pred = int(const void*, const void*);   // exposition only
  extern "C++" using compare-pred = int(const void*, const void*);   // exposition only

  // [support.start.term], start and termination
  [[noreturn]] void abort() noexcept;
  int atexit(c-atexit-handler* func) noexcept;
  int atexit(atexit-handler* func) noexcept;
  int at_quick_exit(c-atexit-handler* func) noexcept;
  int at_quick_exit(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);

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

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

  // [alg.c.library], C standard library algorithms
  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                c-compare-pred* compar);
  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                compare-pred* compar);
  void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);
  void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);

  // [c.math.rand], low-quality random number generation
  int rand();
  void srand(unsigned int seed);

  // [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 [library.c]
  lldiv_t div(long long int numer, long long int denom);        // see [library.c]
  ldiv_t ldiv(long int numer, long int denom);
  lldiv_t lldiv(long long int numer, long long int denom);
}
1
#
The contents and meaning of the header <cstdlib> are the same as the C standard library header <stdlib.h>, except that it does not declare the type wchar_­t, and except as noted in [support.types.nullptr], [support.types.layout], [support.start.term], [c.malloc], [c.mb.wcs], [alg.c.library], [c.math.rand], and [c.math.abs].
[Note
:
Several functions have additional overloads in this document, but they have the same behavior as in the C standard library.
— end note
]
See also: ISO C 7.22

17.2.3 Null pointers [support.types.nullptr]

1
#
The type nullptr_­t is a synonym for the type of a nullptr expression, and it has the characteristics described in [basic.fundamental] and [conv.ptr].
[Note
:
Although nullptr's address cannot be taken, the address of another nullptr_­t object that is an lvalue can be taken.
— end note
]
2
#
The macro NULL is an implementation-defined null pointer constant.182
See also: ISO C 7.19
182)
Possible definitions include 0 and 0L, but not (void*)0.
⮥

17.2.4 Sizes, alignments, and offsets [support.types.layout]

1
#
The macro offsetof(type, member-designator) has the same semantics as the corresponding macro in the C standard library header <stddef.h>, but accepts a restricted set of type arguments in this document.
Use of the offsetof macro with a type other than a standard-layout class ([class.prop]) is conditionally-supported.183
The expression offsetof(type, member-designator) is never type-dependent and it is value-dependent if and only if type is dependent.
The result of applying the offsetof macro to a static data member or a function member is undefined.
No operation invoked by the offsetof macro shall throw an exception and noexcept(offsetof(type, member-designator)) shall be true.
2
#
The type ptrdiff_­t is an implementation-defined signed integer type that can hold the difference of two subscripts in an array object, as described in [expr.add].
3
#
The type size_­t is an implementation-defined unsigned integer type that is large enough to contain the size in bytes of any object ([expr.sizeof]).
4
#
[Note
:
It is recommended that implementations choose types for ptrdiff_­t and size_­t whose integer conversion ranks are no greater than that of signed long int unless a larger size is necessary to contain all the possible values.
— end note
]
5
#
The type 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 ([basic.align]).
See also: ISO C 7.19
183)
Note that offsetof is required to work as specified even if unary operator& is overloaded for any of the types involved.
⮥

17.2.5 byte type operations [support.types.byteops]

🔗
template<class IntType> constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
1
#
Constraints: is_­integral_­v<IntType> is true.
2
#
Effects: Equivalent to: return b = b << shift;
🔗
template<class IntType> constexpr byte operator<<(byte b, IntType shift) noexcept;
3
#
Constraints: is_­integral_­v<IntType> is true.
4
#
Effects: Equivalent to: 
return static_cast<byte>(static_cast<unsigned int>(b) << shift);
🔗
template<class IntType> constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
5
#
Constraints: is_­integral_­v<IntType> is true.
6
#
Effects: Equivalent to: return b = b >> shift;
🔗
template<class IntType> constexpr byte operator>>(byte b, IntType shift) noexcept;
7
#
Constraints: is_­integral_­v<IntType> is true.
8
#
Effects: Equivalent to: 
return static_cast<byte>(static_cast<unsigned int>(b) >> shift);
🔗
constexpr byte& operator|=(byte& l, byte r) noexcept;
9
#
Effects: Equivalent to: return l = l | r;
🔗
constexpr byte operator|(byte l, byte r) noexcept;
10
#
Effects: Equivalent to: 
return static_cast<byte>(static_cast<unsigned int>(l) | static_cast<unsigned int>(r));
🔗
constexpr byte& operator&=(byte& l, byte r) noexcept;
11
#
Effects: Equivalent to: return l = l & r;
🔗
constexpr byte operator&(byte l, byte r) noexcept;
12
#
Effects: Equivalent to: 
return static_cast<byte>(static_cast<unsigned int>(l) & static_cast<unsigned int>(r));
🔗
constexpr byte& operator^=(byte& l, byte r) noexcept;
13
#
Effects: Equivalent to: return l = l ^ r;
🔗
constexpr byte operator^(byte l, byte r) noexcept;
14
#
Effects: Equivalent to: 
return static_cast<byte>(static_cast<unsigned int>(l) ^ static_cast<unsigned int>(r));
🔗
constexpr byte operator~(byte b) noexcept;
15
#
Effects: Equivalent to: 
return static_cast<byte>(~static_cast<unsigned int>(b));
🔗
template<class IntType> constexpr IntType to_integer(byte b) noexcept;
16
#
Constraints: is_­integral_­v<IntType> is true.
17
#
Effects: Equivalent to: return static_­cast<IntType>(b);

17.3 Implementation properties [support.limits]

17.3.1 General [support.limits.general]

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

17.3.2 Header <version> synopsis [version.syn]

1
#
The header <version> supplies implementation-dependent information about the C++ standard library (e.g., version number and release date).
2
#
Each of the macros defined in <version> is also defined after inclusion of any member of the set of library headers indicated in the corresponding comment in this synopsis.
[Note
:
Future versions of this International Standard might replace the values of these macros with greater values.
— end note
]
#define __cpp_lib_addressof_constexpr               201603L // also in <memory>
#define __cpp_lib_allocator_traits_is_always_equal  201411L
  // also in <memory>, <scoped_­allocator>, <string>, <deque>, <forward_­list>, <list>, <vector>,
  // <map>, <set>, <unordered_­map>, <unordered_­set>
#define __cpp_lib_any                               201606L // also in <any>
#define __cpp_lib_apply                             201603L // also in <tuple>
#define __cpp_lib_array_constexpr                   201811L // also in <iterator>, <array>
#define __cpp_lib_as_const                          201510L // also in <utility>
#define __cpp_lib_assume_aligned                    201811L // also in <memory>
#define __cpp_lib_atomic_flag_test                  201907L // also in <atomic>
#define __cpp_lib_atomic_float                      201711L // also in <atomic>
#define __cpp_lib_atomic_is_always_lock_free        201603L // also in <atomic>
#define __cpp_lib_atomic_lock_free_type_aliases     201907L // also in <atomic>
#define __cpp_lib_atomic_ref                        201806L // also in <atomic>
#define __cpp_lib_atomic_shared_ptr                 201711L // also in <memory>
#define __cpp_lib_atomic_value_initialization       201911L // also in <atomic>, <memory>
#define __cpp_lib_atomic_wait                       201907L // also in <atomic>
#define __cpp_lib_barrier                           201907L // also in <barrier>
#define __cpp_lib_bind_front                        201907L // also in <functional>
#define __cpp_lib_bit_cast                          201806L // also in <bit>
#define __cpp_lib_bitops                            201907L // also in <bit>
#define __cpp_lib_bool_constant                     201505L // also in <type_­traits>
#define __cpp_lib_bounded_array_traits              201902L // also in <type_­traits>
#define __cpp_lib_boyer_moore_searcher              201603L // also in <functional>
#define __cpp_lib_byte                              201603L // also in <cstddef>
#define __cpp_lib_char8_t                           201907L
  // also in <atomic>, <filesystem>, <istream>, <limits>, <locale>, <ostream>, <string>, <string_­view>
#define __cpp_lib_chrono                            201907L // also in <chrono>
#define __cpp_lib_chrono_udls                       201304L // also in <chrono>
#define __cpp_lib_clamp                             201603L // also in <algorithm>
#define __cpp_lib_complex_udls                      201309L // also in <complex>
#define __cpp_lib_concepts                          202002L // also in <concepts>
#define __cpp_lib_constexpr_algorithms              201806L // also in <algorithm>
#define __cpp_lib_constexpr_complex                 201711L // also in <complex>
#define __cpp_lib_constexpr_dynamic_alloc           201907L // also in <memory>
#define __cpp_lib_constexpr_functional              201907L // also in <functional>
#define __cpp_lib_constexpr_iterator                201811L // also in <iterator>
#define __cpp_lib_constexpr_memory                  201811L // also in <memory>
#define __cpp_lib_constexpr_numeric                 201911L // also in <numeric>
#define __cpp_lib_constexpr_string                  201907L // also in <string>
#define __cpp_lib_constexpr_string_view             201811L // also in <string_­view>
#define __cpp_lib_constexpr_tuple                   201811L // also in <tuple>
#define __cpp_lib_constexpr_utility                 201811L // also in <utility>
#define __cpp_lib_constexpr_vector                  201907L // also in <vector>
#define __cpp_lib_coroutine                         201902L // also in <coroutine>
#define __cpp_lib_destroying_delete                 201806L // also in <new>
#define __cpp_lib_enable_shared_from_this           201603L // also in <memory>
#define __cpp_lib_endian                            201907L // also in <bit>
#define __cpp_lib_erase_if                          202002L
  // also in <string>, <deque>, <forward_­list>, <list>, <vector>, <map>, <set>, <unordered_­map>,
  // <unordered_­set>
#define __cpp_lib_exchange_function                 201304L // also in <utility>
#define __cpp_lib_execution                         201902L // also in <execution>
#define __cpp_lib_filesystem                        201703L // also in <filesystem>
#define __cpp_lib_format                            201907L // also in <format>
#define __cpp_lib_gcd_lcm                           201606L // also in <numeric>
#define __cpp_lib_generic_associative_lookup        201304L // also in <map>, <set>
#define __cpp_lib_generic_unordered_lookup          201811L
  // also in <unordered_­map>, <unordered_­set>
#define __cpp_lib_hardware_interference_size        201703L // also in <new>
#define __cpp_lib_has_unique_object_representations 201606L // also in <type_­traits>
#define __cpp_lib_hypot                             201603L // also in <cmath>
#define __cpp_lib_incomplete_container_elements     201505L
  // also in <forward_­list>, <list>, <vector>
#define __cpp_lib_int_pow2                          202002L // also in <bit>
#define __cpp_lib_integer_comparison_functions      202002L // also in <utility>
#define __cpp_lib_integer_sequence                  201304L // also in <utility>
#define __cpp_lib_integral_constant_callable        201304L // also in <type_­traits>
#define __cpp_lib_interpolate                       201902L // also in <cmath>, <numeric>
#define __cpp_lib_invoke                            201411L // also in <functional>
#define __cpp_lib_is_aggregate                      201703L // also in <type_­traits>
#define __cpp_lib_is_constant_evaluated             201811L // also in <type_­traits>
#define __cpp_lib_is_final                          201402L // also in <type_­traits>
#define __cpp_lib_is_invocable                      201703L // also in <type_­traits>
#define __cpp_lib_is_layout_compatible              201907L // also in <type_­traits>
#define __cpp_lib_is_nothrow_convertible            201806L // also in <type_­traits>
#define __cpp_lib_is_null_pointer                   201309L // also in <type_­traits>
#define __cpp_lib_is_pointer_interconvertible       201907L // also in <type_­traits>
#define __cpp_lib_is_swappable                      201603L // also in <type_­traits>
#define __cpp_lib_jthread                           201911L // also in <stop_­token>, <thread>
#define __cpp_lib_latch                             201907L // also in <latch>
#define __cpp_lib_launder                           201606L // also in <new>
#define __cpp_lib_list_remove_return_type           201806L // also in <forward_­list>, <list>
#define __cpp_lib_logical_traits                    201510L // also in <type_­traits>
#define __cpp_lib_make_from_tuple                   201606L // also in <tuple>
#define __cpp_lib_make_reverse_iterator             201402L // also in <iterator>
#define __cpp_lib_make_unique                       201304L // also in <memory>
#define __cpp_lib_map_try_emplace                   201411L // also in <map>
#define __cpp_lib_math_constants                    201907L // also in <numbers>
#define __cpp_lib_math_special_functions            201603L // also in <cmath>
#define __cpp_lib_memory_resource                   201603L // also in <memory_­resource>
#define __cpp_lib_node_extract                      201606L
  // also in <map>, <set>, <unordered_­map>, <unordered_­set>
#define __cpp_lib_nonmember_container_access        201411L
  // also in <array>, <deque>, <forward_­list>, <iterator>, <list>, <map>, <regex>, <set>, <string>,
  // <unordered_­map>, <unordered_­set>, <vector>
#define __cpp_lib_not_fn                            201603L // also in <functional>
#define __cpp_lib_null_iterators                    201304L // also in <iterator>
#define __cpp_lib_optional                          201606L // also in <optional>
#define __cpp_lib_parallel_algorithm                201603L // also in <algorithm>, <numeric>
#define __cpp_lib_polymorphic_allocator             201902L // also in <memory>
#define __cpp_lib_quoted_string_io                  201304L // also in <iomanip>
#define __cpp_lib_ranges                            201911L
  // also in <algorithm>, <functional>, <iterator>, <memory>, <ranges>
#define __cpp_lib_raw_memory_algorithms             201606L // also in <memory>
#define __cpp_lib_remove_cvref                      201711L // also in <type_­traits>
#define __cpp_lib_result_of_sfinae                  201210L // also in <functional>, <type_­traits>
#define __cpp_lib_robust_nonmodifying_seq_ops       201304L // also in <algorithm>
#define __cpp_lib_sample                            201603L // also in <algorithm>
#define __cpp_lib_scoped_lock                       201703L // also in <mutex>
#define __cpp_lib_semaphore                         201907L // also in <semaphore>
#define __cpp_lib_shared_mutex                      201505L // also in <shared_­mutex>
#define __cpp_lib_shared_ptr_arrays                 201707L // also in <memory>
#define __cpp_lib_shared_ptr_weak_type              201606L // also in <memory>
#define __cpp_lib_shared_timed_mutex                201402L // also in <shared_­mutex>
#define __cpp_lib_shift                             201806L // also in <algorithm>
#define __cpp_lib_smart_ptr_for_overwrite           202002L // also in <memory>
#define __cpp_lib_source_location                   201907L // also in <source_­location>
#define __cpp_lib_span                              202002L // also in <span>
#define __cpp_lib_ssize                             201902L // also in <iterator>
#define __cpp_lib_starts_ends_with                  201711L // also in <string>, <string_­view>
#define __cpp_lib_string_udls                       201304L // also in <string>
#define __cpp_lib_string_view                       201803L // also in <string>, <string_­view>
#define __cpp_lib_syncbuf                           201803L // also in <syncstream>
#define __cpp_lib_three_way_comparison              201907L // also in <compare>
#define __cpp_lib_to_address                        201711L // also in <memory>
#define __cpp_lib_to_array                          201907L // also in <array>
#define __cpp_lib_to_chars                          201611L // also in <charconv>
#define __cpp_lib_transformation_trait_aliases      201304L // also in <type_­traits>
#define __cpp_lib_transparent_operators             201510L // also in <memory>, <functional>
#define __cpp_lib_tuple_element_t                   201402L // also in <tuple>
#define __cpp_lib_tuples_by_type                    201304L // also in <utility>, <tuple>
#define __cpp_lib_type_identity                     201806L // also in <type_­traits>
#define __cpp_lib_type_trait_variable_templates     201510L // also in <type_­traits>
#define __cpp_lib_uncaught_exceptions               201411L // also in <exception>
#define __cpp_lib_unordered_map_try_emplace         201411L // also in <unordered_­map>
#define __cpp_lib_unwrap_ref                        201811L // also in <type_­traits>
#define __cpp_lib_variant                           201606L // also in <variant>
#define __cpp_lib_void_t                            201411L // also in <type_­traits>

17.3.3 Header <limits> synopsis [limits.syn]

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

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

  template<class T> class numeric_limits<const T>;
  template<class T> class numeric_limits<volatile T>;
  template<class T> class numeric_limits<const volatile T>;

  template<> class numeric_limits<bool>;

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

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

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

17.3.4 Floating-point type properties [fp.style]

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

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

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

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

17.3.5 Class template numeric_­limits [numeric.limits]

1
#
The numeric_­limits class template provides a C++ program with information about various properties of the implementation's representation of the arithmetic types.
namespace std {
  template<class T> class numeric_limits {
  public:
    static constexpr bool is_specialized = false;
    static constexpr T min() noexcept { return T(); }
    static constexpr T max() noexcept { return T(); }
    static constexpr T lowest() noexcept { return T(); }

    static constexpr int  digits = 0;
    static constexpr int  digits10 = 0;
    static constexpr int  max_digits10 = 0;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact = false;
    static constexpr int  radix = 0;
    static constexpr T epsilon() noexcept { return T(); }
    static constexpr T round_error() noexcept { return T(); }

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

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

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

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

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

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

17.3.5.2 numeric_­limits specializations [numeric.special]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

17.3.6 Header <climits> synopsis [climits.syn]

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

17.3.7 Header <cfloat> synopsis [cfloat.syn]

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

17.4 Integer types [cstdint]

17.4.1 Header <cstdint> synopsis [cstdint.syn]

namespace std {
  using int8_t         = signed integer type;  // optional
  using int16_t        = signed integer type;  // optional
  using int32_t        = signed integer type;  // optional
  using int64_t        = signed integer type;  // optional

  using int_fast8_t    = signed integer type;
  using int_fast16_t   = signed integer type;
  using int_fast32_t   = signed integer type;
  using int_fast64_t   = signed integer type;

  using int_least8_t   = signed integer type;
  using int_least16_t  = signed integer type;
  using int_least32_t  = signed integer type;
  using int_least64_t  = signed integer type;

  using intmax_t       = signed integer type;
  using intptr_t       = signed integer type;   // optional

  using uint8_t        = unsigned integer type; // optional
  using uint16_t       = unsigned integer type; // optional
  using uint32_t       = unsigned integer type; // optional
  using uint64_t       = unsigned integer type; // optional

  using uint_fast8_t   = unsigned integer type;
  using uint_fast16_t  = unsigned integer type;
  using uint_fast32_t  = unsigned integer type;
  using uint_fast64_t  = unsigned integer type;

  using uint_least8_t  = unsigned integer type;
  using uint_least16_t = unsigned integer type;
  using uint_least32_t = unsigned integer type;
  using uint_least64_t = unsigned integer type;

  using uintmax_t      = unsigned integer type;
  using uintptr_t      = unsigned integer type; // optional
}
1
#
The header also defines numerous macros of the form: 
  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
plus function macros of the form: 
  [U]INT{8 16 32 64 MAX}_C
2
#
The header defines all types and macros the same as the C standard library header <stdint.h>.
See also: ISO C 7.20

17.5 Startup and termination [support.start.term]

1
#
[Note
:
The header <cstdlib> ([cstdlib.syn]) declares the functions described in this subclause.
— end note
]
🔗
[[noreturn]] void _Exit(int status) noexcept;
2
#
Effects: This function has the semantics specified in the C standard library.
3
#
Remarks: The program is terminated without executing destructors for objects of automatic, thread, or static storage duration and without calling functions passed to atexit() ([basic.start.term]).
The function _­Exit is signal-safe.
🔗
[[noreturn]] void abort() noexcept;
4
#
Effects: This function has the semantics specified in the C standard library.
5
#
Remarks: The program is terminated without executing destructors for objects of automatic, thread, or static storage duration and without calling functions passed to atexit() ([basic.start.term]).
The function abort is signal-safe.
🔗
int atexit(c-atexit-handler* f) noexcept; int atexit(atexit-handler* f) noexcept;
6
#
Effects: The atexit() functions register the function pointed to by f to be called without arguments at normal program termination.
It is unspecified whether a call to atexit() that does not happen before a call to exit() will succeed.
[Note
:
The atexit() functions do not introduce a data race ([res.on.data.races]).
— end note
]
7
#
Implementation limits: The implementation shall support the registration of at least 32 functions.
8
#
Returns: The atexit() function returns zero if the registration succeeds, nonzero if it fails.
🔗
[[noreturn]] void exit(int status);
9
#
Effects:
  • (9.1)
    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 atexit are called.211 See [basic.start.term] for the order of destructions and calls. (Objects with automatic storage duration are not destroyed as a result of calling exit().)212
    If control leaves a registered function called by exit because the function does not provide a handler for a thrown exception, the function std​::​terminate shall be called ([except.terminate]).
  • (9.2)
    Next, all open C streams (as mediated by the function signatures declared in <cstdio> ([cstdio.syn])) with unwritten buffered data are flushed, all open C streams are closed, and all files created by calling tmpfile() are removed.
  • (9.3)
    Finally, control is returned to the host environment. If status is zero or EXIT_­SUCCESS, an implementation-defined form of the status successful termination is returned. If status is EXIT_­FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.213
🔗
int at_quick_exit(c-atexit-handler* f) noexcept; int at_quick_exit(atexit-handler* f) noexcept;
10
#
Effects: The at_­quick_­exit() functions register the function pointed to by f to be called without arguments when quick_­exit is called.
It is unspecified whether a call to at_­quick_­exit() that does not happen before all calls to quick_­exit will succeed.
[Note
:
The at_­quick_­exit() functions do not introduce a data race ([res.on.data.races]).
— end note
]
[Note
:
The order of registration may be indeterminate if at_­quick_­exit was called from more than one thread.
— end note
]
[Note
:
The at_­quick_­exit registrations are distinct from the atexit registrations, and applications may need to call both registration functions with the same argument.
— end note
]
11
#
Implementation limits: The implementation shall support the registration of at least 32 functions.
12
#
Returns: Zero if the registration succeeds, nonzero if it fails.
🔗
[[noreturn]] void quick_exit(int status) noexcept;
13
#
Effects: Functions registered by calls to 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 quick_­exit.
If control leaves a registered function called by quick_­exit because the function does not provide a handler for a thrown exception, the function std​::​terminate shall be called.
[Note
: A function registered via at_­quick_­exit is invoked by the thread that calls 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, quick_­exit shall call _­Exit(status).
14
#
Remarks: The function quick_­exit is signal-safe when the functions registered with at_­quick_­exit are.
See also: ISO C 7.22.4
211)
A function is called for every time it is registered.
⮥
212)
Objects with automatic storage duration are all destroyed in a program whose main function ([basic.start.main]) contains no objects with automatic storage duration and executes the call to exit().
Control can be transferred directly to such a main function by throwing an exception that is caught in main.
⮥
213)
The macros EXIT_­FAILURE and EXIT_­SUCCESS are defined in <cstdlib> ([cstdlib.syn]).
⮥

17.6 Dynamic memory management [support.dynamic]

1
#
The header <new> defines several functions that manage the allocation of dynamic storage in a program.
It also defines components for reporting storage management errors.

17.6.1 Header <new> synopsis [new.syn]

namespace std {
  // [alloc.errors], storage allocation errors
  class bad_alloc;
  class bad_array_new_length;

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

  // global operator new control          
  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;

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

  // [hardware.interference], hardware interference size
  inline constexpr size_t hardware_destructive_interference_size = implementation-defined;
  inline constexpr size_t hardware_constructive_interference_size = implementation-defined;
}

// [new.delete], storage allocation and deallocation
[[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;

17.6.2 Storage allocation and deallocation [new.delete]

1
#
Except where otherwise specified, the provisions of [basic.stc.dynamic] apply to the library versions of operator new and 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.

17.6.2.1 Single-object forms [new.delete.single]

🔗
[[nodiscard]] void* operator new(std::size_t size); [[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
1
#
Effects: The allocation functions called by a new-expression to allocate size bytes of storage.
The second form is called for a type with new-extended alignment, and the first form is called otherwise.
2
#
Replaceable: A C++ program may define functions with either of these function signatures, and thereby displace the default versions defined by the C++ standard library.
3
#
Required behavior: Return a non-null pointer to suitably aligned storage ([basic.stc.dynamic]), or else throw a bad_­alloc exception.
This requirement is binding on any replacement versions of these functions.
4
#
Default behavior:
  • (4.1)
    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 malloc or aligned_­alloc is unspecified.
  • (4.2)
    Returns a pointer to the allocated storage if the attempt is successful. Otherwise, if the current new_­handler ([get.new.handler]) is a null pointer value, throws bad_­alloc.
  • (4.3)
    Otherwise, the function calls the current new_­handler function. If the called function returns, the loop repeats.
  • (4.4)
    The loop terminates when an attempt to allocate the requested storage is successful or when a called new_­handler function does not return.
🔗
[[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;
5
#
Effects: Same as above, except that these are called by a placement version of a new-expression when a C++ program prefers a null pointer result as an error indication, instead of a bad_­alloc exception.
6
#
Replaceable: A C++ program may define functions with either of these function signatures, and thereby displace the default versions defined by the C++ standard library.
7
#
Required behavior: Return a non-null pointer to suitably aligned storage ([basic.stc.dynamic]), or else return a null pointer.
Each of these nothrow versions of 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.
8
#
Default behavior: Calls operator new(size), or operator new(size, alignment), respectively.
If the call returns normally, returns the result of that call.
Otherwise, returns a null pointer.
9
#
[Example
: 
T* p1 = new T;                  // throws bad_­alloc if it fails
T* p2 = new(nothrow) T;         // returns nullptr if it fails
— end example
]
🔗
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;
10
#
Effects: The deallocation functions called by a delete-expression to render the value of ptr invalid.
11
#
Replaceable: A C++ program may define functions with any of these function signatures, and thereby displace the default versions defined by the C++ standard library.
If a function without a size parameter is defined, the program should also define the corresponding function with a size parameter.
If a function with a size parameter is defined, the program shall also define the corresponding version without the size parameter.
[Note
:
The default behavior below may change in the future, which will require replacing both deallocation functions when replacing the allocation function.
— end note
]
12
#
Preconditions: 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) operator new(std​::​size_­t) or operator new(std​::​size_­t, std​::​align_­val_­t) which has not been invalidated by an intervening call to operator delete.
13
#
Preconditions: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr is a safely-derived pointer.
14
#
Preconditions: If the alignment parameter is not present, ptr was returned by an allocation function without an alignment parameter.
If present, the alignment argument is equal to the alignment argument passed to the allocation function that returned ptr.
If present, the size argument is equal to the size argument passed to the allocation function that returned ptr.
15
#
Required behavior: A call to an operator delete with a size parameter may be changed to a call to the corresponding operator delete without a size parameter, without affecting memory allocation.
[Note
:
A conforming implementation is for operator delete(void* ptr, std​::​size_­t size) to simply call operator delete(ptr).
— end note
]
16
#
Default behavior: The functions that have a size parameter forward their other parameters to the corresponding function without a size parameter.
[Note
:
See the note in the above Replaceable: paragraph.
— end note
]
17
#
Default behavior: If ptr is null, does nothing.
Otherwise, reclaims the storage allocated by the earlier call to operator new.
18
#
Remarks: It is unspecified under what conditions part or all of such reclaimed storage will be allocated by subsequent calls to operator new or any of aligned_­alloc, calloc, malloc, or realloc, declared in <cstdlib> ([cstdlib.syn]).
🔗
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;
19
#
Effects: The deallocation functions called by the implementation to render the value of ptr invalid when the constructor invoked from a nothrow placement version of the new-expression throws an exception.
20
#
Replaceable: A C++ program may define functions with either of these function signatures, and thereby displace the default versions defined by the C++ standard library.
21
#
Preconditions: 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) operator new(std​::​size_­t) or operator new(std​::​size_­t, std​::​align_­val_­t) which has not been invalidated by an intervening call to operator delete.
22
#
Preconditions: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr is a safely-derived pointer.
23
#
Preconditions: If the alignment parameter is not present, ptr was returned by an allocation function without an alignment parameter.
If present, the alignment argument is equal to the alignment argument passed to the allocation function that returned ptr.
24
#
Default behavior: Calls operator delete(ptr), or operator delete(ptr, alignment), respectively.

17.6.2.2 Array forms [new.delete.array]

🔗
[[nodiscard]] void* operator new[](std::size_t size); [[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
1
#
Effects: The allocation functions called by the array form of a new-expression to allocate size bytes of storage.
The second form is called for a type with new-extended alignment, and the first form is called otherwise.214
2
#
Replaceable: A C++ program may define functions with either of these function signatures, and thereby displace the default versions defined by the C++ standard library.
3
#
Required behavior: Same as for the corresponding single-object forms.
This requirement is binding on any replacement versions of these functions.
4
#
Default behavior: Returns operator new(size), or operator new(size, alignment), respectively.
🔗
[[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;
5
#
Effects: Same as above, except that these are called by a placement version of a new-expression when a C++ program prefers a null pointer result as an error indication, instead of a bad_­alloc exception.
6
#
Replaceable: A C++ program may define functions with either of these function signatures, and thereby displace the default versions defined by the C++ standard library.
7
#
Required behavior: Return a non-null pointer to suitably aligned storage ([basic.stc.dynamic]), or else return a null pointer.
Each of these nothrow versions of 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.
8
#
Default behavior: Calls operator new[](size), or operator new[](size, alignment), respectively.
If the call returns normally, returns the result of that call.
Otherwise, returns a null pointer.
🔗
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;
9
#
Effects: The deallocation functions called by the array form of a delete-expression to render the value of ptr invalid.
10
#
Replaceable: A C++ program may define functions with any of these function signatures, and thereby displace the default versions defined by the C++ standard library.
If a function without a size parameter is defined, the program should also define the corresponding function with a size parameter.
If a function with a size parameter is defined, the program shall also define the corresponding version without the size parameter.
[Note
:
The default behavior below may change in the future, which will require replacing both deallocation functions when replacing the allocation function.
— end note
]
11
#
Preconditions: 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) operator new[](std​::​size_­t) or operator new[](std​::​size_­t, std​::​align_­val_­t) which has not been invalidated by an intervening call to operator delete[].
12
#
Preconditions: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr is a safely-derived pointer.
13
#
Preconditions: If the alignment parameter is not present, ptr was returned by an allocation function without an alignment parameter.
If present, the alignment argument is equal to the alignment argument passed to the allocation function that returned ptr.
If present, the size argument is equal to the size argument passed to the allocation function that returned ptr.
14
#
Required behavior: A call to an operator delete[] with a size parameter may be changed to a call to the corresponding operator delete[] without a size parameter, without affecting memory allocation.
[Note
:
A conforming implementation is for operator delete[](void* ptr, std​::​size_­t size) to simply call operator delete[](ptr).
— end note
]
15
#
Default behavior: The functions that have a size parameter forward their other parameters to the corresponding function without a size parameter.
The functions that do not have a size parameter forward their parameters to the corresponding operator delete (single-object) function.
🔗
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;
16
#
Effects: The deallocation functions called by the implementation to render the value of ptr invalid when the constructor invoked from a nothrow placement version of the array new-expression throws an exception.
17
#
Replaceable: A C++ program may define functions with either of these function signatures, and thereby displace the default versions defined by the C++ standard library.
18
#
Preconditions: 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) operator new[](std​::​size_­t) or operator new[](std​::​size_­t, std​::​align_­val_­t) which has not been invalidated by an intervening call to operator delete[].
19
#
Preconditions: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr is a safely-derived pointer.
20
#
Preconditions: If the alignment parameter is not present, ptr was returned by an allocation function without an alignment parameter.
If present, the alignment argument is equal to the alignment argument passed to the allocation function that returned ptr.
21
#
Default behavior: Calls operator delete[](ptr), or operator delete[](ptr, alignment), respectively.
214)
It is not the direct responsibility of operator new[] or operator delete[] to note the repetition count or element size of the array.
Those operations are performed elsewhere in the array new and delete expressions.
The array new expression, may, however, increase the size argument to operator new[] to obtain space to store supplemental information.
⮥

17.6.2.3 Non-allocating forms [new.delete.placement]

1
#
These functions are reserved; a C++ program may not define functions that displace the versions in the C++ standard library ([constraints]).
The provisions of [basic.stc.dynamic] do not apply to these reserved placement forms of operator new and operator delete.
🔗
[[nodiscard]] void* operator new(std::size_t size, void* ptr) noexcept;
2
#
Returns: ptr.
3
#
Remarks: Intentionally performs no other action.
4
#
[Example
:
This can be useful for constructing an object at a known address:
void* place = operator new(sizeof(Something));
Something* p = new (place) Something();
— end example
]
🔗
[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
5
#
Returns: ptr.
6
#
Remarks: Intentionally performs no other action.
🔗
void operator delete(void* ptr, void*) noexcept;
7
#
Effects: Intentionally performs no action.
8
#
Preconditions: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr is a safely-derived pointer.
9
#
Remarks: Default function called when any part of the initialization in a placement new-expression that invokes the library's non-array placement operator new terminates by throwing an exception ([expr.new]).
🔗
void operator delete[](void* ptr, void*) noexcept;
10
#
Effects: Intentionally performs no action.
11
#
Preconditions: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr is a safely-derived pointer.
12
#
Remarks: Default function called when any part of the initialization in a placement new-expression that invokes the library's array placement operator new terminates by throwing an exception ([expr.new]).

17.6.2.4 Data races [new.delete.dataraces]

1
#
For purposes of determining the existence of data races, the library versions of operator new, user replacement versions of global operator new, the C standard library functions aligned_­alloc, calloc, and malloc, the library versions of operator delete, user replacement versions of operator delete, the C standard library function free, and the C standard library function realloc shall not introduce a data race ([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 the next allocation (if any) in this order.

17.6.3 Storage allocation errors [alloc.errors]

17.6.3.1 Class bad_­alloc [bad.alloc]

namespace std {
  class bad_alloc : public exception {
  public:
    // see [exception] for the specification of the special member functions
    const char* what() const noexcept override;
  };
}
1
#
The class bad_­alloc defines the type of objects thrown as exceptions by the implementation to report a failure to allocate storage.
🔗
const char* what() const noexcept override;
2
#
Returns: An implementation-defined ntbs.

17.6.3.2 Class bad_­array_­new_­length [new.badlength]

namespace std {
  class bad_array_new_length : public bad_alloc {
  public:
    // see [exception] for the specification of the special member functions
    const char* what() const noexcept override;
  };
}
1
#
The class 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 implementation-defined limit ([expr.new]).
🔗
const char* what() const noexcept override;
2
#
Returns: An implementation-defined ntbs.

17.6.3.3 Type new_­handler [new.handler]

🔗
using new_handler = void (*)();
1
#
The type of a handler function to be called by operator new() or operator new[]() ([new.delete]) when they cannot satisfy a request for additional storage.
2
#
Required behavior: A new_­handler shall perform one of the following:
  • (2.1)
    make more storage available for allocation and then return;
  • (2.2)
    throw an exception of type bad_­alloc or a class derived from bad_­alloc;
  • (2.3)
    terminate execution of the program without returning to the caller.

17.6.3.4 set_­new_­handler [set.new.handler]

🔗
new_handler set_new_handler(new_handler new_p) noexcept;
1
#
Effects: Establishes the function designated by new_­p as the current new_­handler.
2
#
Returns: The previous new_­handler.
3
#
Remarks: The initial new_­handler is a null pointer.

17.6.3.5 get_­new_­handler [get.new.handler]

🔗
new_handler get_new_handler() noexcept;
1
#
Returns: The current new_­handler.
[Note
:
This may be a null pointer value.
— end note
]

17.6.4 Pointer optimization barrier [ptr.launder]

🔗
template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
1
#
Mandates: !is_­function_­v<T> && !is_­void_­v<T> is true.
2
#
Preconditions: p represents the address A of a byte in memory.
An object X that is within its lifetime and whose type is similar to T is located at the address A.
All bytes of storage that would be reachable through the result are reachable through p (see below).
3
#
Returns: A value of type T* that points to X.
4
#
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 b is reachable through a pointer value that points to an object Y if there is an object Z, pointer-interconvertible with Y, such that b is within the storage occupied by Z, or the immediately-enclosing array object if Z is an array element.
5
#
[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 its complete object is a const object or it is a base class subobject; in the latter cases, this function can be used to obtain a usable pointer to the new object.
— end note
]
6
#
[Example
: 
struct X { int n; };
const X *p = new const X{3};
const int a = p->n;
new (const_cast<X*>(p)) const X{5}; // p does not point to new object ([basic.life]) because its type is const
const int b = p->n;                 // undefined behavior
const int c = std::launder(p)->n;   // OK
— end example
]

17.6.5 Hardware interference size [hardware.interference]

🔗
inline constexpr size_t hardware_destructive_interference_size = implementation-defined;
1
#
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 alignof(max_­align_­t).
[Example
: 
struct keep_apart {
  alignas(hardware_destructive_interference_size) atomic<int> cat;
  alignas(hardware_destructive_interference_size) atomic<int> dog;
};
— end example
]
🔗
inline constexpr size_t hardware_constructive_interference_size = implementation-defined;
2
#
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 alignof(max_­align_­t).
[Example
: 
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 example
]

17.7 Type identification [support.rtti]

1
#
The header <typeinfo> defines a type associated with type information generated by the implementation.
It also defines two types for reporting dynamic type identification errors.

17.7.1 Header <typeinfo> synopsis [typeinfo.syn]

namespace std {
  class type_info;
  class bad_cast;
  class bad_typeid;
}

17.7.2 Class type_­info [type.info]

namespace std {
  class type_info {
  public:
    virtual ~type_info();
    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&) = delete;                   // cannot be copied
    type_info& operator=(const type_info&) = delete;        // cannot be copied
  };
}
1
#
The class type_­info describes type information generated by the implementation ([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 and may differ between programs.
🔗
bool operator==(const type_info& rhs) const noexcept;
2
#
Effects: Compares the current object with rhs.
3
#
Returns: true if the two values describe the same type.
🔗
bool before(const type_info& rhs) const noexcept;
4
#
Effects: Compares the current object with rhs.
5
#
Returns: true if *this precedes rhs in the implementation's collation order.
🔗
size_t hash_code() const noexcept;
6
#
Returns: An unspecified value, except that within a single execution of the program, it shall return the same value for any two type_­info objects which compare equal.
7
#
Remarks: An implementation should return different values for two type_­info objects which do not compare equal.
🔗
const char* name() const noexcept;
8
#
Returns: An implementation-defined ntbs.
9
#
Remarks: The message may be a null-terminated multibyte string, suitable for conversion and display as a wstring ([string.classes], [locale.codecvt]).

17.7.3 Class bad_­cast [bad.cast]

namespace std {
  class bad_cast : public exception {
  public:
    // see [exception] for the specification of the special member functions
    const char* what() const noexcept override;
  };
}
1
#
The class bad_­cast defines the type of objects thrown as exceptions by the implementation to report the execution of an invalid dynamic_­cast expression ([expr.dynamic.cast]).
🔗
const char* what() const noexcept override;
2
#
Returns: An implementation-defined ntbs.

17.7.4 Class bad_­typeid [bad.typeid]

namespace std {
  class bad_typeid : public exception {
  public:
    // see [exception] for the specification of the special member functions
    const char* what() const noexcept override;
  };
}
1
#
The class bad_­typeid defines the type of objects thrown as exceptions by the implementation to report a null pointer in a typeid expression ([expr.typeid]).
🔗
const char* what() const noexcept override;
2
#
Returns: An implementation-defined ntbs.

17.8 Source location [support.srcloc]

17.8.1 Header <source_­location> synopsis [source.location.syn]

The header <source_­location> defines the class source_­location that provides a means to obtain source location information.
namespace std {
  struct source_location;
}

17.8.2 Class source_­location [support.srcloc.class]

namespace std {
  struct source_location {
    // source location construction
    static consteval source_location current() noexcept;
    constexpr source_location() noexcept;

    // source location field access
    constexpr uint_least32_t line() const noexcept;
    constexpr uint_least32_t column() const noexcept;
    constexpr const char* file_name() const noexcept;
    constexpr const char* function_name() const noexcept;

  private:
    uint_least32_t line_;               // exposition only
    uint_least32_t column_;             // exposition only
    const char* file_name_;             // exposition only
    const char* function_name_;         // exposition only
  };
}
1
#
The type source_­location meets the Cpp17DefaultConstructible, Cpp17CopyConstructible, Cpp17CopyAssignable, and Cpp17Destructible requirements ([utility.arg.requirements]).
Lvalues of type source_­location are swappable ([swappable.requirements]).
All of the following conditions are true:
  • (1.1)
    is_­nothrow_­move_­constructible_­v<source_­location>
  • (1.2)
    is_­nothrow_­move_­assignable_­v<source_­location>
  • (1.3)
    is_­nothrow_­swappable_­v<source_­location>
[Note
: The intent of source_­location is to have a small size and efficient copying. It is unspecified whether the copy/move constructors and the copy/move assignment operators are trivial and/or constexpr. — end note
]
2
#
The data members file_­name_­ and function_­name_­ always each refer to an ntbs.
3
#
The copy/move constructors and the copy/move assignment operators of source_­location meet the following postconditions: Given two objects lhs and rhs of type source_­location, where lhs is a copy/move result of rhs, and where rhs_­p is a value denoting the state of rhs before the corresponding copy/move operation, then each of the following conditions is true:
  • (3.1)
    strcmp(lhs.file_­name(), rhs_­p.file_­name()) == 0
  • (3.2)
    strcmp(lhs.function_­name(), rhs_­p.function_­name()) == 0
  • (3.3)
    lhs.line() == rhs_­p.line()
  • (3.4)
    lhs.column() == rhs_­p.column()

17.8.2.1 Creation [support.srcloc.cons]

🔗
static consteval source_location current() noexcept;
1
#
Returns:
  • (1.1)
    When invoked by a function call whose postfix-expression is a (possibly parenthesized) id-expression naming current, returns a source_­location with an implementation-defined value. The value should be affected by #line ([cpp.line]) in the same manner as for __LINE__ and __FILE__. The values of the exposition-only data members of the returned source_­location object are indicated in Table 38.
    Table 38: Value of object returned by current   [tab:support.srcloc.current]
    ElementValue
    line_­A presumed line number ([cpp.predefined]). Line numbers are presumed to be 1-indexed; however, an implementation is encouraged to use 0 when the line number is unknown.
    column_­An implementation-defined value denoting some offset from the start of the line denoted by line_­. Column numbers are presumed to be 1-indexed; however, an implementation is encouraged to use 0 when the column number is unknown.
    file_­name_­A presumed name of the current source file ([cpp.predefined]) as an ntbs.
    function_­name_­A name of the current function such as in __func__ ([dcl.fct.def.general]) if any, an empty string otherwise.
  • (1.2)
    Otherwise, when invoked in some other way, returns a source_­location whose data members are initialized with valid but unspecified values.
2
#
Remarks: Any call to current that appears as a default member initializer ([class.mem]), or as a subexpression thereof, should correspond to the location of the constructor definition or aggregate initialization that uses the default member initializer.
Any call to current that appears as a default argument ([dcl.fct.default]), or as a subexpression thereof, should correspond to the location of the invocation of the function that uses the default argument ([expr.call]).
3
#
[Example
: 
struct s {
  source_location member = source_location::current();
  int other_member;
  s(source_location loc = source_location::current())
    : member(loc)               // values of member refer to the location of the calling function ([dcl.fct.default])
  {}
  s(int blather) :              // values of member refer to this location
    other_member(blather)
  {}
  s(double)                     // values of member refer to this location
  {}
};
void f(source_location a = source_location::current()) {
  source_location b = source_location::current();       // values in b refer to this line
}

void g() {
  f();                          // f's first argument corresponds to this line of code

  source_location c = source_location::current();
  f(c);                         // f's first argument gets the same values as c, above
}
— end example
]
🔗
constexpr source_location() noexcept;
4
#
Effects: The data members are initialized with valid but unspecified values.

17.8.2.2 Observers [support.srcloc.obs]

🔗
constexpr uint_least32_t line() const noexcept;
1
#
Returns: line_­.
🔗
constexpr uint_least32_t column() const noexcept;
2
#
Returns: column_­.
🔗
constexpr const char* file_name() const noexcept;
3
#
Returns: file_­name_­.
🔗
constexpr const char* function_name() const noexcept;
4
#
Returns: function_­name_­.

17.9 Exception handling [support.exception]

1
#
The header <exception> defines several types and functions related to the handling of exceptions in a C++ program.

17.9.1 Header <exception> synopsis [exception.syn]

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

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

17.9.2 Class exception [exception]

namespace std {
  class exception {
  public:
    exception() noexcept;
    exception(const exception&) noexcept;
    exception& operator=(const exception&) noexcept;
    virtual ~exception();
    virtual const char* what() const noexcept;
  };
}
1
#
The class exception defines the base class for the types of objects thrown as exceptions by C++ standard library components, and certain expressions, to report errors detected during program execution.
2
#
Each standard library class T that derives from class exception has the following publicly accessible member functions, each of them having a non-throwing exception specification ([except.spec]):
  • (2.1)
    default constructor (unless the class synopsis shows other constructors)
  • (2.2)
    copy constructor
  • (2.3)
    copy assignment operator
The copy constructor and the copy assignment operator meet the following postcondition: If two objects lhs and rhs both have dynamic type T and lhs is a copy of rhs, then strcmp(lhs.what(), rhs.what()) is equal to 0.
The what() member function of each such T satisfies the constraints specified for exception​::​what() (see below).
🔗
exception(const exception& rhs) noexcept; exception& operator=(const exception& rhs) noexcept;
3
#
Postconditions: If *this and rhs both have dynamic type exception then the value of the expression strcmp(what(), rhs.what()) shall equal 0.
🔗
virtual ~exception();
4
#
Effects: Destroys an object of class exception.
🔗
virtual const char* what() const noexcept;
5
#
Returns: An implementation-defined ntbs.
6
#
Remarks: The message may be a null-terminated multibyte string, suitable for conversion and display as a wstring ([string.classes], [locale.codecvt]).
The return value remains valid until the exception object from which it is obtained is destroyed or a non-const member function of the exception object is called.

17.9.3 Class bad_­exception [bad.exception]

namespace std {
  class bad_exception : public exception {
  public:
    // see [exception] for the specification of the special member functions
    const char* what() const noexcept override;
  };
}
1
#
The class bad_­exception defines the type of the object referenced by the exception_­ptr returned from a call to current_­exception ([propagation]) when the currently active exception object fails to copy.
🔗
const char* what() const noexcept override;
2
#
Returns: An implementation-defined ntbs.

17.9.4 Abnormal termination [exception.terminate]

17.9.4.1 Type terminate_­handler [terminate.handler]

🔗
using terminate_handler = void (*)();
1
#
The type of a handler function to be called by std​::​terminate() when terminating exception processing.
2
#
Required behavior: A terminate_­handler shall terminate execution of the program without returning to the caller.
3
#
Default behavior: The implementation's default terminate_­handler calls abort().

17.9.4.2 set_­terminate [set.terminate]

🔗
terminate_handler set_terminate(terminate_handler f) noexcept;
1
#
Effects: Establishes the function designated by f as the current handler function for terminating exception processing.
2
#
Remarks: It is unspecified whether a null pointer value designates the default terminate_­handler.
3
#
Returns: The previous terminate_­handler.

17.9.4.3 get_­terminate [get.terminate]

🔗
terminate_handler get_terminate() noexcept;
1
#
Returns: The current terminate_­handler.
[Note
:
This may be a null pointer value.
— end note
]

17.9.4.4 terminate [terminate]

🔗
[[noreturn]] void terminate() noexcept;
1
#
Remarks: Called by the implementation when exception handling must be abandoned for any of several reasons ([except.terminate]).
May also be called directly by the program.
2
#
Effects: Calls a terminate_­handler function.
It is unspecified which terminate_­handler function will be called if an exception is active during a call to set_­terminate.
Otherwise calls the current terminate_­handler function.
[Note
:
A default terminate_­handler is always considered a callable handler in this context.
— end note
]

17.9.5 uncaught_­exceptions [uncaught.exceptions]

🔗
int uncaught_exceptions() noexcept;
1
#
Returns: The number of uncaught exceptions.
2
#
Remarks: When uncaught_­exceptions() > 0, throwing an exception can result in a call of the function std​::​terminate.

17.9.6 Exception propagation [propagation]

🔗
using exception_ptr = unspecified;
1
#
The type exception_­ptr can be used to refer to an exception object.
2
#
exception_­ptr meets the requirements of Cpp17NullablePointer (Table 33).
3
#
Two non-null values of type exception_­ptr are equivalent and compare equal if and only if they refer to the same exception.
4
#
The default constructor of exception_­ptr produces the null value of the type.
5
#
exception_­ptr shall not be implicitly convertible to any arithmetic, enumeration, or pointer type.
6
#
[Note
:
An implementation might use a reference-counted smart pointer as exception_­ptr.
— end note
]
7
#
For purposes of determining the presence of a data race, operations on exception_­ptr objects shall access and modify only the exception_­ptr objects themselves and not the exceptions they refer to.
Use of rethrow_­exception on exception_­ptr objects that refer to the same exception object shall not introduce a data race.
[Note
:
If 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 exception_­ptr objects that refer to a particular exception do not introduce a data race.
— end note
]
🔗
exception_ptr current_exception() noexcept;
8
#
Returns: An exception_­ptr object that refers to the currently handled exception or a copy of the currently handled exception, or a null exception_­ptr object if no exception is being handled.
The referenced object shall remain valid at least as long as there is an exception_­ptr object that refers to it.
If the function needs to allocate memory and the attempt fails, it returns an exception_­ptr object that refers to an instance of bad_­alloc.
It is unspecified whether the return values of two successive calls to current_­exception refer to the same exception object.
[Note
:
That is, it is unspecified whether 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 exception_­ptr object that refers to the thrown exception or, if this is not possible, to an instance of bad_­exception.
[Note
:
The copy constructor of the thrown exception may also fail, so the implementation is allowed to substitute a bad_­exception object to avoid infinite recursion.
— end note
]
🔗
[[noreturn]] void rethrow_exception(exception_ptr p);
9
#
Preconditions: p is not a null pointer.
10
#
Throws: The exception object to which p refers.
🔗
template<class E> exception_ptr make_exception_ptr(E e) noexcept;
11
#
Effects: Creates an exception_­ptr object that refers to a copy of e, as if: 
try {
  throw e;
} catch(...) {
  return current_exception();
}
12
#
[Note
:
This function is provided for convenience and efficiency reasons.
— end note
]

17.9.7 nested_­exception [except.nested]

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);
}
1
#
The class nested_­exception is designed for use as a mixin through multiple inheritance.
It captures the currently handled exception and stores it for later use.
2
#
[Note
:
nested_­exception has a virtual destructor to make it a polymorphic class.
Its presence can be tested for with dynamic_­cast.
— end note
]
🔗
nested_exception() noexcept;
3
#
Effects: The constructor calls current_­exception() and stores the returned value.
🔗
[[noreturn]] void rethrow_nested() const;
4
#
Effects: If nested_­ptr() returns a null pointer, the function calls the function std​::​terminate.
Otherwise, it throws the stored exception captured by *this.
🔗
exception_ptr nested_ptr() const noexcept;
5
#
Returns: The stored exception captured by this nested_­exception object.
🔗
template<class T> [[noreturn]] void throw_with_nested(T&& t);
6
#
Let U be decay_­t<T>.
7
#
Preconditions: U meets the Cpp17CopyConstructible requirements.
8
#
Throws: If is_­class_­v<U> && !is_­final_­v<U> && !is_­base_­of_­v<nested_­exception, U> is true, an exception of unspecified type that is publicly derived from both U and nested_­exception and constructed from std​::​forward<T>(t), otherwise std​::​forward<T>(t).
🔗
template<class E> void rethrow_if_nested(const E& e);
9
#
Effects: If E is not a polymorphic class type, or if nested_­exception is an inaccessible or ambiguous base class of E, there is no effect.
Otherwise, performs: 
if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
  p->rethrow_nested();

17.10 Initializer lists [support.initlist]

1
#
The header <initializer_­list> defines a class template and several support functions related to list-initialization (see [dcl.init.list]).
All functions specified in this subclause are signal-safe.

17.10.1 Header <initializer_­list> synopsis [initializer.list.syn]

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

  // [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;
}
1
#
An object of type initializer_­list<E> provides access to an array of objects of type const E.
[Note
:
A pair of pointers or a pointer plus a length would be obvious representations for initializer_­list.
initializer_­list is used to implement initializer lists as specified in [dcl.init.list].
Copying an initializer list does not copy the underlying elements.
— end note
]
2
#
If an explicit specialization or partial specialization of initializer_­list is declared, the program is ill-formed.

17.10.2 Initializer list constructors [support.initlist.cons]

🔗
constexpr initializer_list() noexcept;
1
#
Postconditions: size() == 0.

17.10.3 Initializer list access [support.initlist.access]

🔗
constexpr const E* begin() const noexcept;
1
#
Returns: A pointer to the beginning of the array.
If size() == 0 the values of begin() and end() are unspecified but they shall be identical.
🔗
constexpr const E* end() const noexcept;
2
#
Returns: begin() + size().
🔗
constexpr size_t size() const noexcept;
3
#
Returns: The number of elements in the array.
4
#
Complexity: Constant time.

17.10.4 Initializer list range access [support.initlist.range]

🔗
template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
1
#
Returns: il.begin().
🔗
template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
2
#
Returns: il.end().

17.11 Comparisons [cmp]

17.11.1 Header <compare> synopsis [compare.syn]

1
#
The header <compare> specifies types, objects, and functions for use primarily in connection with the three-way comparison operator.
namespace std {
  // [cmp.categories], comparison category types
  class partial_ordering;
  class weak_ordering;
  class strong_ordering;

  // named comparison functions
  constexpr bool is_eq  (partial_ordering cmp) noexcept { return cmp == 0; }
  constexpr bool is_neq (partial_ordering 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; }

  // [cmp.common], common comparison category type
  template<class... Ts>
  struct common_comparison_category {
    using type = see below;
  };
  template<class... Ts>
    using common_comparison_category_t = typename common_comparison_category<Ts...>::type;

  // [cmp.concept], concept three_­way_­comparable
  template<class T, class Cat = partial_ordering>
    concept three_way_comparable = see below;
  template<class T, class U, class Cat = partial_ordering>
    concept three_way_comparable_with = see below;

  // [cmp.result], result of three-way comparison
  template<class T, class U = T> struct compare_three_way_result;

  template<class T, class U = T>
    using compare_three_way_result_t = typename compare_three_way_result<T, U>::type;

  // [comparisons.three.way], class compare_­three_­way
  struct compare_three_way;

  // [cmp.alg], comparison algorithms
  inline namespace unspecified {
    inline constexpr unspecified strong_order = unspecified;
    inline constexpr unspecified weak_order = unspecified;
    inline constexpr unspecified partial_order = unspecified;
    inline constexpr unspecified compare_strong_order_fallback = unspecified;
    inline constexpr unspecified compare_weak_order_fallback = unspecified;
    inline constexpr unspecified compare_partial_order_fallback = unspecified;
  }
}

17.11.2 Comparison category types [cmp.categories]

17.11.2.1 Preamble [cmp.categories.pre]

1
#
The types partial_­ordering, weak_­ordering, and strong_­ordering are collectively termed the comparison category types.
Each is specified in terms of an exposition-only data member named value whose value typically corresponds to that of an enumerator from one of the following exposition-only enumerations:
enum class eq { equal = 0, equivalent = equal,
                nonequal = 1, nonequivalent = nonequal };   // exposition only
enum class ord { less = -1, greater = 1 };                  // exposition only
enum class ncmp { unordered = -127 };                       // exposition only
2
#
[Note
:
The type strong_­ordering corresponds to the term total ordering in mathematics.
— end note
]
3
#
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 0 as a corresponding argument.
[Example
:
nullptr_­t meets this requirement.
— end example
]
In this context, the behavior of a program that supplies an argument other than a literal 0 is undefined.
4
#
For the purposes of subclause [cmp.categories], substitutability is the property that f(a) == f(b) is true whenever a == b is true, where f denotes a function that reads only comparison-salient state that is accessible via the argument's public const members.

17.11.2.2 Class partial_­ordering [cmp.partialord]

1
#
The partial_­ordering type is typically used as the result type of a three-way comparison operator that (a) admits all of the six two-way comparison operators ([expr.rel], [expr.eq]), (b) does not imply substitutability, and (c) permits two values to be incomparable.215
namespace std {
  class partial_ordering {
    int value;          // exposition only
    bool is_ordered;    // exposition only

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

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

    // comparisons
    friend constexpr bool operator==(partial_ordering v, unspecified) noexcept;
    friend constexpr bool operator==(partial_ordering v, partial_ordering w) noexcept = default;
    friend constexpr bool operator< (partial_ordering v, unspecified) noexcept;
    friend constexpr bool operator> (partial_ordering v, unspecified) noexcept;
    friend constexpr bool operator<=(partial_ordering v, unspecified) noexcept;
    friend constexpr bool operator>=(partial_ordering v, unspecified) noexcept;
    friend constexpr bool operator< (unspecified, partial_ordering v) noexcept;
    friend constexpr bool operator> (unspecified, partial_ordering v) noexcept;
    friend constexpr bool operator<=(unspecified, partial_ordering v) noexcept;
    friend constexpr bool operator>=(unspecified, partial_ordering v) noexcept;
    friend constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
    friend constexpr partial_ordering operator<=>(unspecified, 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);
}
🔗
constexpr bool operator==(partial_ordering v, unspecified) noexcept; constexpr bool operator< (partial_ordering v, unspecified) noexcept; constexpr bool operator> (partial_ordering v, unspecified) noexcept; constexpr bool operator<=(partial_ordering v, unspecified) noexcept; constexpr bool operator>=(partial_ordering v, unspecified) noexcept;
2
#
Returns: For operator@, v.is_­ordered && v.value @ 0.
🔗
constexpr bool operator< (unspecified, partial_ordering v) noexcept; constexpr bool operator> (unspecified, partial_ordering v) noexcept; constexpr bool operator<=(unspecified, partial_ordering v) noexcept; constexpr bool operator>=(unspecified, partial_ordering v) noexcept;
3
#
Returns: For operator@, v.is_­ordered && 0 @ v.value.
🔗
constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
4
#
Returns: v.
🔗
constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
5
#
Returns: v < 0 ? partial_­ordering​::​greater : v > 0 ? partial_­ordering​::​less : v.
215)
That is, a < b, a == b, and a > b might all be false.
⮥

17.11.2.3 Class weak_­ordering [cmp.weakord]

1
#
The weak_­ordering type is typically used as the result type of a three-way comparison operator that (a) admits all of the six two-way comparison operators ([expr.rel], [expr.eq]), and (b) does not imply substitutability.
namespace std {
  class weak_ordering {
    int value;  // exposition only

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

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

    // conversions
    constexpr operator partial_ordering() const noexcept;

    // comparisons
    friend constexpr bool operator==(weak_ordering v, unspecified) noexcept;
    friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;
    friend constexpr bool operator< (weak_ordering v, unspecified) noexcept;
    friend constexpr bool operator> (weak_ordering v, unspecified) noexcept;
    friend constexpr bool operator<=(weak_ordering v, unspecified) noexcept;
    friend constexpr bool operator>=(weak_ordering v, unspecified) noexcept;
    friend constexpr bool operator< (unspecified, weak_ordering v) noexcept;
    friend constexpr bool operator> (unspecified, weak_ordering v) noexcept;
    friend constexpr bool operator<=(unspecified, weak_ordering v) noexcept;
    friend constexpr bool operator>=(unspecified, weak_ordering v) noexcept;
    friend constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
    friend constexpr weak_ordering operator<=>(unspecified, 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);
}
🔗
constexpr operator partial_ordering() const noexcept;
2
#
Returns: 
value == 0 ? partial_ordering::equivalent :
value < 0  ? partial_ordering::less :
             partial_ordering::greater
🔗
constexpr bool operator==(weak_ordering v, unspecified) noexcept; constexpr bool operator< (weak_ordering v, unspecified) noexcept; constexpr bool operator> (weak_ordering v, unspecified) noexcept; constexpr bool operator<=(weak_ordering v, unspecified) noexcept; constexpr bool operator>=(weak_ordering v, unspecified) noexcept;
3
#
Returns: v.value @ 0 for operator@.
🔗
constexpr bool operator< (unspecified, weak_ordering v) noexcept; constexpr bool operator> (unspecified, weak_ordering v) noexcept; constexpr bool operator<=(unspecified, weak_ordering v) noexcept; constexpr bool operator>=(unspecified, weak_ordering v) noexcept;
4
#
Returns: 0 @ v.value for operator@.
🔗
constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
5
#
Returns: v.
🔗
constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
6
#
Returns: v < 0 ? weak_­ordering​::​greater : v > 0 ? weak_­ordering​::​less : v.

17.11.2.4 Class strong_­ordering [cmp.strongord]

1
#
The strong_­ordering type is typically used as the result type of a three-way comparison operator that (a) admits all of the six two-way comparison operators ([expr.rel], [expr.eq]), and (b) does imply substitutability.
namespace std {
  class strong_ordering {
    int value;  // exposition only

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

  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 partial_ordering() const noexcept;
    constexpr operator weak_ordering() const noexcept;

    // comparisons
    friend constexpr bool operator==(strong_ordering v, unspecified) noexcept;
    friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default;
    friend constexpr bool operator< (strong_ordering v, unspecified) noexcept;
    friend constexpr bool operator> (strong_ordering v, unspecified) noexcept;
    friend constexpr bool operator<=(strong_ordering v, unspecified) noexcept;
    friend constexpr bool operator>=(strong_ordering v, unspecified) noexcept;
    friend constexpr bool operator< (unspecified, strong_ordering v) noexcept;
    friend constexpr bool operator> (unspecified, strong_ordering v) noexcept;
    friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
    friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
    friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
    friend constexpr strong_ordering operator<=>(unspecified, 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);
}
🔗
constexpr operator partial_ordering() const noexcept;
2
#
Returns: 
value == 0 ? partial_ordering::equivalent :
value < 0  ? partial_ordering::less :
             partial_ordering::greater
🔗
constexpr operator weak_ordering() const noexcept;
3
#
Returns: 
value == 0 ? weak_ordering::equivalent :
value < 0  ? weak_ordering::less :
             weak_ordering::greater
🔗
constexpr bool operator==(strong_ordering v, unspecified) noexcept; constexpr bool operator< (strong_ordering v, unspecified) noexcept; constexpr bool operator> (strong_ordering v, unspecified) noexcept; constexpr bool operator<=(strong_ordering v, unspecified) noexcept; constexpr bool operator>=(strong_ordering v, unspecified) noexcept;
4
#
Returns: v.value @ 0 for operator@.
🔗
constexpr bool operator< (unspecified, strong_ordering v) noexcept; constexpr bool operator> (unspecified, strong_ordering v) noexcept; constexpr bool operator<=(unspecified, strong_ordering v) noexcept; constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
5
#
Returns: 0 @ v.value for operator@.
🔗
constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
6
#
Returns: v.
🔗
constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
7
#
Returns: v < 0 ? strong_­ordering​::​greater : v > 0 ? strong_­ordering​::​less : v.

17.11.3 Class template common_­comparison_­category [cmp.common]

1
#
The type common_­comparison_­category provides an alias for the strongest comparison category to which all of the template arguments can be converted.
[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
]
🔗
template<class... Ts> struct common_comparison_category { using type = see below; };
2
#
Remarks: The member typedef-name type denotes the common comparison type ([class.spaceship]) of Ts..., the expanded parameter pack, or void if any element of Ts is not a comparison category type.
[Note
:
This is std​::​strong_­ordering if the expansion is empty.
— end note
]

17.11.4 Concept three_­way_­comparable [cmp.concept]

template<class T, class Cat>
  concept compares-as =                 // exposition only
    same_as<common_comparison_category_t<T, Cat>, Cat>;

template<class T, class U>
  concept partially-ordered-with =      // exposition only
    requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
      { t <  u } -> boolean-testable;
      { t >  u } -> boolean-testable;
      { t <= u } -> boolean-testable;
      { t >= u } -> boolean-testable;
      { u <  t } -> boolean-testable;
      { u >  t } -> boolean-testable;
      { u <= t } -> boolean-testable;
      { u >= t } -> boolean-testable;
    };
1
#
Let t and u be lvalues of types const remove_­reference_­t<T> and const remove_­reference_­t<U>, respectively.
T and U model partially-ordered-with<T, U> only if:
  • (1.1)
    t < u, t <= u, t > u, t >= u, u < t, u <= t, u > t, and u >= t have the same domain.
  • (1.2)
    bool(t < u) == bool(u > t) is true,
  • (1.3)
    bool(u < t) == bool(t > u) is true,
  • (1.4)
    bool(t <= u) == bool(u >= t) is true, and
  • (1.5)
    bool(u <= t) == bool(t >= u) is true.
template<class T, class Cat = partial_ordering>
  concept three_way_comparable =
    weakly-equality-comparable-with<T, T> &&
    partially-ordered-with<T, T> &&
    requires(const remove_reference_t<T>& a, const remove_reference_t<T>& b) {
      { a <=> b } -> compares-as<Cat>;
    };
2
#
Let a and b be lvalues of type const remove_­reference_­t<T>.
T and Cat model three_­way_­comparable<T, Cat> only if:
  • (2.1)
    (a <=> b == 0) == bool(a == b) is true,
  • (2.2)
    (a <=> b != 0) == bool(a != b) is true,
  • (2.3)
    ((a <=> b) <=> 0) and (0 <=> (b <=> a)) are equal,
  • (2.4)
    (a <=> b < 0) == bool(a < b) is true,
  • (2.5)
    (a <=> b > 0) == bool(a > b) is true,
  • (2.6)
    (a <=> b <= 0) == bool(a <= b) is true,
  • (2.7)
    (a <=> b >= 0) == bool(a >= b) is true, and
  • (2.8)
    if Cat is convertible to strong_­ordering, T models totally_­ordered ([concept.totallyordered]).
template<class T, class U, class Cat = partial_ordering>
  concept three_way_comparable_with =
    three_way_comparable<T, Cat> &&
    three_way_comparable<U, Cat> &&
    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
    three_way_comparable<
      common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
    weakly-equality-comparable-with<T, U> &&
    partially-ordered-with<T, U> &&
    requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
      { t <=> u } -> compares-as<Cat>;
      { u <=> t } -> compares-as<Cat>;
    };
3
#
Let t and u be lvalues of types const remove_­reference_­t<T> and const remove_­reference_­t<U>, respectively.
Let C be common_­reference_­t<const remove_­reference_­t<T>&, const remove_­reference_­t<U>&>.
T, U, and Cat model three_­way_­comparable_­with<T, U, Cat> only if:
  • (3.1)
    t <=> u and u <=> t have the same domain,
  • (3.2)
    ((t <=> u) <=> 0) and (0 <=> (u <=> t)) are equal,
  • (3.3)
    (t <=> u == 0) == bool(t == u) is true,
  • (3.4)
    (t <=> u != 0) == bool(t != u) is true,
  • (3.5)
    Cat(t <=> u) == Cat(C(t) <=> C(u)) is true,
  • (3.6)
    (t <=> u < 0) == bool(t < u) is true,
  • (3.7)
    (t <=> u > 0) == bool(t > u) is true,
  • (3.8)
    (t <=> u <= 0) == bool(t <= u) is true,
  • (3.9)
    (t <=> u >= 0) == bool(t >= u) is true, and
  • (3.10)
    if Cat is convertible to strong_­ordering, T and U model totally_­ordered_­with<T, U> ([concept.totallyordered]).

17.11.5 Result of three-way comparison [cmp.result]

1
#
The behavior of a program that adds specializations for the compare_­three_­way_­result template defined in this subclause is undefined.
2
#
For the compare_­three_­way_­result type trait applied to the types T and U, let t and u denote lvalues of types const remove_­reference_­t<T> and const remove_­reference_­t<U>, respectively.
If the expression t <=> u is well-formed when treated as an unevaluated operand ([expr.context]), the member typedef-name type denotes the type decltype(t <=> u).
Otherwise, there is no member type.

17.11.6 Comparison algorithms [cmp.alg]

1
#
The name strong_­order denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expression strong_­order(E, F) is expression-equivalent ([defns.expression-equivalent]) to the following:
  • (1.1)
    If the decayed types of E and F differ, strong_­order(E, F) is ill-formed.
  • (1.2)
    Otherwise, strong_­ordering(strong_­order(E, F)) if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of std​::​strong_­order.
  • (1.3)
    Otherwise, if the decayed type T of E is a floating-point type, yields a value of type strong_­ordering that is consistent with the ordering observed by T's comparison operators, and if numeric_­limits<T>​::​is_­iec559 is true, is additionally consistent with the totalOrder operation as specified in ISO/IEC/IEEE 60559.
  • (1.4)
    Otherwise, strong_­ordering(compare_­three_­way()(E, F)) if it is a well-formed expression.
  • (1.5)
    Otherwise, strong_­order(E, F) is ill-formed.
    [Note
    : This case can result in substitution failure when strong_­order(E, F) appears in the immediate context of a template instantiation. — end note
    ]
2
#
The name weak_­order denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expression weak_­order(E, F) is expression-equivalent ([defns.expression-equivalent]) to the following:
  • (2.1)
    If the decayed types of E and F differ, weak_­order(E, F) is ill-formed.
  • (2.2)
    Otherwise, weak_­ordering(weak_­order(E, F)) if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of std​::​weak_­order.
  • (2.3)
    Otherwise, if the decayed type T of E is a floating-point type, yields a value of type weak_­ordering that is consistent with the ordering observed by T's comparison operators and strong_­order, and if numeric_­limits<T>​::​is_­iec559 is true, is additionally consistent with the following equivalence classes, ordered from lesser to greater:
  • (2.4)
    Otherwise, weak_­ordering(compare_­three_­way()(E, F)) if it is a well-formed expression.
  • (2.5)
    Otherwise, weak_­ordering(strong_­order(E, F)) if it is a well-formed expression.
  • (2.6)
    Otherwise, weak_­order(E, F) is ill-formed.
    [Note
    : This case can result in substitution failure when std​::​weak_­order(E, F) appears in the immediate context of a template instantiation. — end note
    ]
3
#
The name partial_­order denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expression partial_­order(E, F) is expression-equivalent ([defns.expression-equivalent]) to the following:
  • (3.1)
    If the decayed types of E and F differ, partial_­order(E, F) is ill-formed.
  • (3.2)
    Otherwise, partial_­ordering(partial_­order(E, F)) if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of std​::​partial_­order.
  • (3.3)
    Otherwise, partial_­ordering(compare_­three_­way()(E, F)) if it is a well-formed expression.
  • (3.4)
    Otherwise, partial_­ordering(weak_­order(E, F)) if it is a well-formed expression.
  • (3.5)
    Otherwise, partial_­order(E, F) is ill-formed.
    [Note
    : This case can result in substitution failure when std​::​partial_­order(E, F) appears in the immediate context of a template instantiation. — end note
    ]
4
#
The name compare_­strong_­order_­fallback denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expression compare_­strong_­order_­fallback(E, F) is expression-equivalent ([defns.expression-equivalent]) to:
  • (4.1)
    If the decayed types of E and F differ, compare_­strong_­order_­fallback(E, F) is ill-formed.
  • (4.2)
    Otherwise, strong_­order(E, F) if it is a well-formed expression.
  • (4.3)
    Otherwise, if the expressions E == F and E < F are both well-formed and convertible to bool, 
    E == F ? strong_ordering::equal :
E < F  ? strong_ordering::less :
         strong_ordering::greater
    except that E and F are evaluated only once.
  • (4.4)
    Otherwise, compare_­strong_­order_­fallback(E, F) is ill-formed.
5
#
The name compare_­weak_­order_­fallback denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expression compare_­weak_­order_­fallback(E, F) is expression-equivalent ([defns.expression-equivalent]) to:
  • (5.1)
    If the decayed types of E and F differ, compare_­weak_­order_­fallback(E, F) is ill-formed.
  • (5.2)
    Otherwise, weak_­order(E, F) if it is a well-formed expression.
  • (5.3)
    Otherwise, if the expressions E == F and E < F are both well-formed and convertible to bool, 
    E == F ? weak_ordering::equivalent :
E < F  ? weak_ordering::less :
         weak_ordering::greater
    except that E and F are evaluated only once.
  • (5.4)
    Otherwise, compare_­weak_­order_­fallback(E, F) is ill-formed.
6
#
The name compare_­partial_­order_­fallback denotes a customization point object ([customization.point.object]).
Given subexpressions E and F, the expression compare_­partial_­order_­fallback(E, F) is expression-equivalent ([defns.expression-equivalent]) to:
  • (6.1)
    If the decayed types of E and F differ, compare_­partial_­order_­fallback(E, F) is ill-formed.
  • (6.2)
    Otherwise, partial_­order(E, F) if it is a well-formed expression.
  • (6.3)
    Otherwise, if the expressions E == F and E < F are both well-formed and convertible to bool, 
    E == F ? partial_ordering::equivalent :
E < F  ? partial_ordering::less :
F < E  ? partial_ordering::greater :
         partial_ordering::unordered
    except that E and F are evaluated only once.
  • (6.4)
    Otherwise, compare_­partial_­order_­fallback(E, F) is ill-formed.

17.12 Coroutines [support.coroutine]

1
#
The header <coroutine> defines several types providing compile and run-time support for coroutines in a C++ program.

17.12.1 Header <coroutine> synopsis [coroutine.syn]

#include <compare>              // see [compare.syn]

namespace std {
  // [coroutine.traits], coroutine traits
  template<class R, class... ArgTypes>
    struct coroutine_traits;

  // [coroutine.handle], coroutine handle
  template<class Promise = void>
    struct coroutine_handle;

  // [coroutine.handle.compare], comparison operators
  constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
  constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;

  // [coroutine.handle.hash], hash support
  template<class T> struct hash;
  template<class P> struct hash<coroutine_handle<P>>;

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

  // [coroutine.trivial.awaitables], trivial awaitables
  struct suspend_never;
  struct suspend_always;
}

17.12.2 Coroutine traits [coroutine.traits]

1
#
This subclause defines requirements on classes representing coroutine traits, and defines the class template coroutine_­traits that meets those requirements.

17.12.2.1 Class template coroutine_­traits [coroutine.traits.primary]

1
#
The header <coroutine> defines the primary template coroutine_­traits such that if ArgTypes is a parameter pack of types and if the qualified-id R​::​promise_­type is valid and denotes a type ([temp.deduct]), then coroutine_­traits<R,ArgTypes...> has the following publicly accessible member:
using promise_type = typename R::promise_type;
Otherwise, coroutine_­traits<R,ArgTypes...> has no members.
2
#
Program-defined specializations of this template shall define a publicly accessible nested type named promise_­type.

17.12.3 Class template coroutine_­handle [coroutine.handle]

namespace std {
  template<>
  struct coroutine_handle<void>
  {
    // [coroutine.handle.con], construct/reset
    constexpr coroutine_handle() noexcept;
    constexpr coroutine_handle(nullptr_t) noexcept;
    coroutine_handle& operator=(nullptr_t) noexcept;

    // [coroutine.handle.export.import], export/import
    constexpr void* address() const noexcept;
    static constexpr coroutine_handle from_address(void* addr);

    // [coroutine.handle.observers], observers
    constexpr explicit operator bool() const noexcept;
    bool done() const;

    // [coroutine.handle.resumption], resumption
    void operator()() const;
    void resume() const;
    void destroy() const;

  private:
    void* ptr;  // exposition only
  };

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

    // [coroutine.handle.export.import], export/import
    static constexpr coroutine_handle from_address(void* addr);

    // [coroutine.handle.promise], promise access
    Promise& promise() const;
  };
}
1
#
An object of type coroutine_­handle<T> is called a coroutine handle and can be used to refer to a suspended or executing coroutine.
A default-constructed coroutine_­handle object does not refer to any coroutine.
2
#
If a program declares an explicit or partial specialization of coroutine_­handle, the behavior is undefined.

17.12.3.1 Construct/reset [coroutine.handle.con]

🔗
constexpr coroutine_handle() noexcept; constexpr coroutine_handle(nullptr_t) noexcept;
1
#
Postconditions: address() == nullptr.
🔗
static coroutine_handle from_promise(Promise& p);
2
#
Preconditions: p is a reference to a promise object of a coroutine.
3
#
Returns: A coroutine handle h referring to the coroutine.
4
#
Postconditions: addressof(h.promise()) == addressof(p).
🔗
coroutine_handle& operator=(nullptr_t) noexcept;
5
#
Postconditions: address() == nullptr.
6
#
Returns: *this.

17.12.3.2 Export/import [coroutine.handle.export.import]

🔗
constexpr void* address() const noexcept;
1
#
Returns: ptr.
🔗
static constexpr coroutine_handle<> coroutine_handle<>::from_address(void* addr); static constexpr coroutine_handle<Promise> coroutine_handle<Promise>::from_address(void* addr);
2
#
Preconditions: addr was obtained via a prior call to address.
3
#
Postconditions: from_­address(address()) == *this.

17.12.3.3 Observers [coroutine.handle.observers]

🔗
constexpr explicit operator bool() const noexcept;
1
#
Returns: address() != nullptr.
🔗
bool done() const;
2
#
Preconditions: *this refers to a suspended coroutine.
3
#
Returns: true if the coroutine is suspended at its final suspend point, otherwise false.

17.12.3.4 Resumption [coroutine.handle.resumption]

1
#
Resuming a coroutine via resume, operator(), or destroy on an execution agent other than the one on which it was suspended has implementation-defined behavior unless each execution agent either is an instance of std​::​thread or std​::​jthread, or is the thread that executes main.
[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
]
[Note
:
A concurrent resumption of the coroutine may result in a data race.
— end note
]
🔗
void operator()() const; void resume() const;
2
#
Preconditions: *this refers to a suspended coroutine.
The coroutine is not suspended at its final suspend point.
3
#
Effects: Resumes the execution of the coroutine.
🔗
void destroy() const;
4
#
Preconditions: *this refers to a suspended coroutine.
5
#
Effects: Destroys the coroutine ([dcl.fct.def.coroutine]).

17.12.3.5 Promise access [coroutine.handle.promise]

🔗
Promise& promise() const;
1
#
Preconditions: *this refers to a coroutine.
2
#
Returns: A reference to the promise of the coroutine.

17.12.3.6 Comparison operators [coroutine.handle.compare]

🔗
constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
1
#
Returns: x.address() == y.address().
🔗
constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
2
#
Returns: compare_­three_­way()(x.address(), y.address()).

17.12.3.7 Hash support [coroutine.handle.hash]

🔗
template<class P> struct hash<coroutine_handle<P>>;
1
#
The specialization is enabled ([unord.hash]).

17.12.4 No-op coroutines [coroutine.noop]

17.12.4.1 Class noop_­coroutine_­promise [coroutine.promise.noop]

🔗
struct noop_coroutine_promise {};
1
#
The class noop_­coroutine_­promise defines the promise type for the coroutine referred to by noop_­coroutine_­handle ([coroutine.syn]).

17.12.4.2 Class coroutine_­handle<noop_­coroutine_­promise> [coroutine.handle.noop]

namespace std {
  template<>
  struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
  {
    // [coroutine.handle.noop.observers], observers
    constexpr explicit operator bool() const noexcept;
    constexpr bool done() const noexcept;

    // [coroutine.handle.noop.resumption], resumption
    constexpr void operator()() const noexcept;
    constexpr void resume() const noexcept;
    constexpr void destroy() const noexcept;

    // [coroutine.handle.noop.promise], promise access
    noop_coroutine_promise& promise() const noexcept;

    // [coroutine.handle.noop.address], address
    constexpr void* address() const noexcept;
  private:
    coroutine_handle(unspecified);
  };
}

17.12.4.2.1 Observers [coroutine.handle.noop.observers]

🔗
constexpr explicit operator bool() const noexcept;
1
#
Returns: true.
🔗
constexpr bool done() const noexcept;
2
#
Returns: false.

17.12.4.2.2 Resumption [coroutine.handle.noop.resumption]

🔗
constexpr void operator()() const noexcept; constexpr void resume() const noexcept; constexpr void destroy() const noexcept;
1
#
Effects: None.
2
#
Remarks: If noop_­coroutine_­handle is converted to coroutine_­handle<>, calls to operator(), resume and destroy on that handle will also have no observable effects.

17.12.4.2.3 Promise access [coroutine.handle.noop.promise]

🔗
noop_coroutine_promise& promise() const noexcept;
1
#
Returns: A reference to the promise object associated with this coroutine handle.

17.12.4.2.4 Address [coroutine.handle.noop.address]

🔗
constexpr void* address() const noexcept;
1
#
Returns: ptr.
2
#
Remarks: A noop_­coroutine_­handle's ptr is always a non-null pointer value.

17.12.4.3 Function noop_­coroutine [coroutine.noop.coroutine]

🔗
noop_coroutine_handle noop_coroutine() noexcept;
1
#
Returns: A handle to a coroutine that has no observable effects when resumed or destroyed.
2
#
Remarks: A handle returned from noop_­coroutine may or may not compare equal to a handle returned from another invocation of noop_­coroutine.

17.12.5 Trivial awaitables [coroutine.trivial.awaitables]

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 {}
  };
}
1
#
[Note
:
The types suspend_­never and suspend_­always can be used to indicate that an await-expression should either never suspend or always suspend, and in either case not produce a value.
— end note
]

17.13 Other runtime support [support.runtime]

1
#
Headers <csetjmp> (nonlocal jumps), <csignal> (signal handling), <cstdarg> (variable arguments), and <cstdlib> (runtime environment getenv, system), provide further compatibility with C code.
2
#
Calls to the function getenv ([cstdlib.syn]) shall not introduce a data race ([res.on.data.races]) provided that nothing modifies the environment.
[Note
:
Calls to the POSIX functions setenv and putenv modify the environment.
— end note
]
3
#
A call to the setlocale function may introduce a data race with other calls to the 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 locale​::​global calls the setlocale function.

17.13.1 Header <cstdarg> synopsis [cstdarg.syn]

namespace std {
  using va_­list = see below;
}

#define va_­arg(V, P) see below
#define va_­copy(VDST, VSRC) see below
#define va_­end(V) see below
#define va_­start(V, P) see below
1
#
The contents of the header <cstdarg> are the same as the C standard library header <stdarg.h>, with the following changes: The restrictions that ISO C places on the second parameter to the va_­start macro in header <stdarg.h> are different in this document.
The parameter parmN is the rightmost parameter in the variable parameter list of the function definition (the one just before the ...).216
If the parameter parmN is a pack expansion ([temp.variadic]) or an entity resulting from a lambda capture ([expr.prim.lambda]), the program is ill-formed, no diagnostic required.
If the parameter 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.
See also: ISO C 7.16.1.1
216)
Note that va_­start is required to work as specified even if unary operator& is overloaded for the type of parmN.
⮥

17.13.2 Header <csetjmp> synopsis [csetjmp.syn]

namespace std {
  using jmp_buf = see below;
  [[noreturn]] void longjmp(jmp_buf env, int val);
}

#define setjmp(env) see below
1
#
The contents of the header <csetjmp> are the same as the C standard library header <setjmp.h>.
2
#
The function signature longjmp(jmp_­buf jbuf, int val) has more restricted behavior in this document.
A setjmp/longjmp call pair has undefined behavior if replacing the setjmp and longjmp by catch and throw would invoke any non-trivial destructors for any objects with automatic storage duration.
A call to setjmp or longjmp has undefined behavior if invoked in a suspension context of a coroutine ([expr.await]).
See also: ISO C 7.13

17.13.3 Header <csignal> synopsis [csignal.syn]

namespace std {
  using sig_atomic_t = see below;

  // [support.signal], signal handlers
  extern "C" using signal-handler = void(int);  // exposition only
  signal-handler* signal(int sig, signal-handler* func);

  int raise(int sig);
}

#define SIG_DFL see below
#define SIG_ERR see below
#define SIG_IGN see below
#define SIGABRT see below
#define SIGFPE see below
#define SIGILL see below
#define SIGINT see below
#define SIGSEGV see below
#define SIGTERM see below
1
#
The contents of the header <csignal> are the same as the C standard library header <signal.h>.

17.13.4 Signal handlers [support.signal]

1
#
A call to the function signal synchronizes with any resulting invocation of the signal handler so installed.
2
#
A plain lock-free atomic operation is an invocation of a function f from [atomics], such that:
  • (2.1)
    f is the function atomic_­is_­lock_­free(), or
  • (2.2)
    f is the member function is_­lock_­free(), or
  • (2.3)
    f is a non-static member function invoked on an object A, such that A.is_­lock_­free() yields true, or
  • (2.4)
    f is a non-member function, and for every pointer-to-atomic argument A passed to f, atomic_­is_­lock_­free(A) yields true.
3
#
An evaluation is signal-safe unless it includes one of the following:
  • (3.1)
    a call to any standard library function, except for plain lock-free atomic operations and functions explicitly identified as signal-safe;
    [Note
    : This implicitly excludes the use of new and delete expressions that rely on a library-provided memory allocator. — end note
    ]
  • (3.2)
    an access to an object with thread storage duration;
  • (3.3)
    a dynamic_­cast expression;
  • (3.4)
    throwing of an exception;
  • (3.5)
    control entering a try-block or function-try-block;
  • (3.6)
    initialization of a variable with static storage duration requiring dynamic initialization ([basic.start.dynamic], [stmt.dcl])217; or
  • (3.7)
    waiting for the completion of the initialization of a variable with static storage duration ([stmt.dcl]).
A signal handler invocation has undefined behavior if it includes an evaluation that is not signal-safe.
4
#
The function 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.
See also: ISO C 7.14
217)
Such initialization might occur because it is the first odr-use ([basic.def.odr]) of that variable.
⮥