[atomics.types.generic] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpb5w6lx58/{from.md → to.md} +482 -197

tmp/tmpb5w6lx58/{from.md → to.md} RENAMED Viewed

@@ -17,35 +17,35 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     T load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    T load(memory_order = memory_order::seq_cst) const noexcept;
     operator T() const volatile noexcept;
-    operator T() const noexcept;
     void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(T, memory_order = memory_order::seq_cst) noexcept;
     T operator=(T) volatile noexcept;
-    T operator=(T) noexcept;
     T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept;
-    T exchange(T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept;
     void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(T, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The template argument for `T` shall meet the *Cpp17CopyConstructible*
@@ -53,19 +53,21 @@ and *Cpp17CopyAssignable* requirements. The program is ill-formed if any
 of
 - `is_trivially_copyable_v<T>`,
 - `is_copy_constructible_v<T>`,
 - `is_move_constructible_v<T>`,
-- `is_copy_assignable_v<T>`, or
-- `is_move_assignable_v<T>`
 is `false`.
 [*Note 1*: Type arguments that are not also statically initializable
 can be difficult to use. — *end note*]
-The specialization `atomic<bool>` is a standard-layout struct.
 [*Note 2*: The representation of an atomic specialization need not have
 the same size and alignment requirement as its corresponding argument
 type. — *end note*]
@@ -73,11 +75,11 @@ type. — *end note*]
 ``` cpp
 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
 ```
-*Mandates:* `is_default_constructible_v<T>` is `true`.
 *Effects:* Initializes the atomic object with the value of `T()`.
 Initialization is not an atomic operation [[intro.multithread]].
 ``` cpp
@@ -117,27 +119,26 @@ otherwise.
 consistent with the value of `is_always_lock_free` for the same
 type. — *end note*]
 ``` cpp
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
-void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
-*Preconditions:* The `order` argument is neither
-`memory_order::consume`, `memory_order::acquire`, nor
-`memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
 T operator=(T desired) volatile noexcept;
-T operator=(T desired) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -145,36 +146,36 @@ T operator=(T desired) noexcept;
 *Returns:* `desired`.
 ``` cpp
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
-T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
-*Preconditions:* The `order` argument is neither `memory_order::release`
-nor `memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `this`.
 ``` cpp
 operator T() const volatile noexcept;
-operator T() const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return load();`
 ``` cpp
 T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
-T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -187,31 +188,31 @@ operations [[intro.multithread]].
 before the effects.
 ``` cpp
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) volatile noexcept;
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) volatile noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) noexcept;
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) volatile noexcept;
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) volatile noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
-*Preconditions:* The `failure` argument is neither
-`memory_order::release` nor `memory_order::acq_rel`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value pointed to by `this` for
 equality with that previously retrieved from `expected`, and if true,
 replaces the value pointed to by `this` with that in `desired`. If and
@@ -296,14 +297,14 @@ preferable. — *end note*]
 [*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
 compare-and-exchange operations apply, the comparisons can fail for
 values that compare equal with `operator==` if the value representation
 has trap bits or alternate representations of the same value. Notably,
-on implementations conforming to ISO/IEC/IEEE 60559, floating-point
-`-0.0` and `+0.0` will not compare equal with `memcmp` but will compare
-equal with `operator==`, and NaNs with the same payload will compare
-equal with `memcmp` but will not compare equal with
 `operator==`. — *end note*]
 [*Note 7*:
 Because compare-and-exchange acts on an object’s value representation,
@@ -350,15 +351,15 @@ bool party(pony desired) {
 — *end note*]
 ``` cpp
 void wait(T old, memory_order order = memory_order::seq_cst) const volatile noexcept;
-void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
@@ -369,11 +370,11 @@ void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 *Remarks:* This function is an atomic waiting
 operation [[atomics.wait]].
 ``` cpp
 void notify_one() volatile noexcept;
-void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
@@ -381,11 +382,11 @@ call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
 void notify_all() volatile noexcept;
-void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
@@ -421,85 +422,122 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(integral-type, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(integral-type, memory_order = memory_order::seq_cst) noexcept;
     integral-type operator=(integral-type) volatile noexcept;
-    integral-type operator=(integral-type) noexcept;
     integral-type load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    integral-type load(memory_order = memory_order::seq_cst) const noexcept;
     operator integral-type() const volatile noexcept;
-    operator integral-type() const noexcept;
     integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_xor(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_xor(integral-type,
                              memory_order = memory_order::seq_cst) noexcept;
     integral-type operator++(int) volatile noexcept;
-    integral-type operator++(int) noexcept;
     integral-type operator--(int) volatile noexcept;
-    integral-type operator--(int) noexcept;
     integral-type operator++() volatile noexcept;
-    integral-type operator++() noexcept;
     integral-type operator--() volatile noexcept;
-    integral-type operator--() noexcept;
     integral-type operator+=(integral-type) volatile noexcept;
-    integral-type operator+=(integral-type) noexcept;
     integral-type operator-=(integral-type) volatile noexcept;
-    integral-type operator-=(integral-type) noexcept;
     integral-type operator&=(integral-type) volatile noexcept;
-    integral-type operator&=(integral-type) noexcept;
     integral-type operator|=(integral-type) volatile noexcept;
-    integral-type operator|=(integral-type) noexcept;
     integral-type operator^=(integral-type) volatile noexcept;
-    integral-type operator^=(integral-type) noexcept;
     void wait(integral-type, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The atomic integral specializations are standard-layout structs. They
@@ -513,18 +551,21 @@ correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 **Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
 |       |     |             |       |     |                      |
-| ----- | --- | -------------------- | ----- | --- | -------------------- |
-| `add` | `+` | addition | `sub` | `-` | subtraction          |
-| `or` | `|` | bitwise inclusive or | `xor` | `^` | bitwise exclusive or |
-| `and` | `&` | bitwise and          |       |     |                      |
 ``` cpp
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -535,21 +576,59 @@ the given `operand`. Memory is affected according to the value of
 operations [[intro.multithread]].
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
-*Remarks:* For signed integer types, the result is as if the object
-value and parameters were converted to their corresponding unsigned
-types, the computation performed on those types, and the result
-converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
 ``` cpp
-T operator op=(T operand) volatile noexcept;
-T operator op=(T operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -579,59 +658,117 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator=(floating-point-type) volatile noexcept;
-    floating-point-type operator=(floating-point-type) noexcept;
     floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
     operator floating-point-type() volatile noexcept;
-    operator floating-point-type() noexcept;
     floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type exchange(floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order, memory_order) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order, memory_order) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type fetch_add(floating-point-type,
                                             memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type fetch_sub(floating-point-type,
                                       memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator+=(floating-point-type) volatile noexcept;
-    floating-point-type operator+=(floating-point-type) noexcept;
     floating-point-type operator-=(floating-point-type) volatile noexcept;
-    floating-point-type operator-=(floating-point-type) noexcept;
     void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The atomic floating-point specializations are standard-layout structs.
@@ -640,15 +777,19 @@ They each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic addition and subtraction
 computations. The correspondence among key, operator, and computation is
-specified in [[atomic.types.int.comp]].
 ``` cpp
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -669,13 +810,92 @@ otherwise have no undefined behavior. Atomic arithmetic operations on
 the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
 *`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
-T operator op=(T operand) volatile noexcept;
-T operator op=(T operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -709,57 +929,70 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(T*, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(T*, memory_order = memory_order::seq_cst) noexcept;
     T* operator=(T*) volatile noexcept;
-    T* operator=(T*) noexcept;
     T* load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    T* load(memory_order = memory_order::seq_cst) const noexcept;
     operator T*() const volatile noexcept;
-    operator T*() const noexcept;
     T* exchange(T*, memory_order = memory_order::seq_cst) volatile noexcept;
-    T* exchange(T*, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) noexcept;
     T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
-    T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
     T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
-    T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
     T* operator++(int) volatile noexcept;
-    T* operator++(int) noexcept;
     T* operator--(int) volatile noexcept;
-    T* operator--(int) noexcept;
     T* operator++() volatile noexcept;
-    T* operator++() noexcept;
     T* operator--() volatile noexcept;
-    T* operator--() noexcept;
     T* operator+=(ptrdiff_t) volatile noexcept;
-    T* operator+=(ptrdiff_t) noexcept;
     T* operator-=(ptrdiff_t) volatile noexcept;
-    T* operator-=(ptrdiff_t) noexcept;
     void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 There is a partial specialization of the `atomic` class template for
@@ -776,14 +1009,15 @@ among key, operator, and computation is specified in
 **Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
 |       |     |          |       |     |             |
 | ----- | --- | -------- | ----- | --- | ----------- |
 | `add` | `+` | addition | `sub` | `-` | subtraction |
 ``` cpp
-T* fetch_key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) volatile noexcept;
-T* fetch_key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -802,13 +1036,51 @@ operations [[intro.multithread]].
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
 ``` cpp
 T* operator op=(ptrdiff_t operand) volatile noexcept;
-T* operator op=(ptrdiff_t operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -817,41 +1089,41 @@ T* operator op=(ptrdiff_t operand) noexcept;
 #### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
 value_type operator++(int) volatile noexcept;
-value_type operator++(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
 value_type operator--(int) volatile noexcept;
-value_type operator--(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
 value_type operator++() volatile noexcept;
-value_type operator++() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
 value_type operator--() volatile noexcept;
-value_type operator--() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -924,33 +1196,36 @@ namespace std {
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
     constexpr atomic(nullptr_t) noexcept : atomic() { }
-    atomic(shared_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
-    shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
-    operator shared_ptr<T>() const noexcept;
-    void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
-    void operator=(shared_ptr<T> desired) noexcept;
-    shared_ptr<T> exchange(shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
-    void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
-    void notify_one() noexcept;
-    void notify_all() noexcept;
   private:
     shared_ptr<T> p;            // exposition only
   };
 }
@@ -958,14 +1233,14 @@ namespace std {
 ``` cpp
 constexpr atomic() noexcept;
 ```
-*Effects:* Initializes `p{}`.
 ``` cpp
-atomic(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
@@ -975,63 +1250,70 @@ the just-constructed object `A` to another thread via
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
-void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::consume`,
-`memory_order::acquire`, nor `memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
-void operator=(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
-shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
-operator shared_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
-shared_ptr<T> exchange(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
-bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
-bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
-*Preconditions:* `failure` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
@@ -1052,11 +1334,11 @@ object in the attempted atomic update. The `use_count` update
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
-bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -1068,11 +1350,11 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -1084,15 +1366,15 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
@@ -1102,22 +1384,22 @@ void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const n
 *Remarks:* Two `shared_ptr` objects are equivalent if they store the
 same pointer and either share ownership or are both empty. This function
 is an atomic waiting operation [[atomics.wait]].
 ``` cpp
-void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
-void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
@@ -1133,33 +1415,35 @@ namespace std {
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
-    atomic(weak_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
-    weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
-    operator weak_ptr<T>() const noexcept;
-    void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
-    void operator=(weak_ptr<T> desired) noexcept;
-    weak_ptr<T> exchange(weak_ptr<T> desired,
                                    memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
-    void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
-    void notify_one() noexcept;
-    void notify_all() noexcept;
   private:
     weak_ptr<T> p;              // exposition only
   };
 }
@@ -1167,14 +1451,14 @@ namespace std {
 ``` cpp
 constexpr atomic() noexcept;
 ```
-*Effects:* Initializes `p{}`.
 ``` cpp
-atomic(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
@@ -1184,63 +1468,64 @@ the just-constructed object `A` to another thread via
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
-void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::consume`,
-`memory_order::acquire`, nor `memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
-void operator=(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
-weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
-operator weak_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
-weak_ptr<T> exchange(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
-bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
-bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
-*Preconditions:* `failure` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
@@ -1261,11 +1546,11 @@ object in the attempted atomic update. The `use_count` update
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
-bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -1277,11 +1562,11 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -1293,15 +1578,15 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
@@ -1311,22 +1596,22 @@ void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noe
 *Remarks:* Two `weak_ptr` objects are equivalent if they store the same
 pointer and either share ownership or are both empty. This function is
 an atomic waiting operation [[atomics.wait]].
 ``` cpp
-void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
-void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.

     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     T load(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr T load(memory_order = memory_order::seq_cst) const noexcept;
     operator T() const volatile noexcept;
+ constexpr operator T() const noexcept;
     void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(T, memory_order = memory_order::seq_cst) noexcept;
     T operator=(T) volatile noexcept;
+ constexpr T operator=(T) noexcept;
     T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T exchange(T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept;
     void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(T, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The template argument for `T` shall meet the *Cpp17CopyConstructible*
 of
 - `is_trivially_copyable_v<T>`,
 - `is_copy_constructible_v<T>`,
 - `is_move_constructible_v<T>`,
+- `is_copy_assignable_v<T>`,
+- `is_move_assignable_v<T>`, or
+- `is_same_v<T, remove_cv_t<T>>`,
 is `false`.
 [*Note 1*: Type arguments that are not also statically initializable
 can be difficult to use. — *end note*]
+The specialization `atomic<bool>` is a standard-layout struct. It has a
+trivial destructor.
 [*Note 2*: The representation of an atomic specialization need not have
 the same size and alignment requirement as its corresponding argument
 type. — *end note*]
 ``` cpp
 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
 ```
+*Constraints:* `is_default_constructible_v<T>` is `true`.
 *Effects:* Initializes the atomic object with the value of `T()`.
 Initialization is not an atomic operation [[intro.multithread]].
 ``` cpp
 consistent with the value of `is_always_lock_free` for the same
 type. — *end note*]
 ``` cpp
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
 T operator=(T desired) volatile noexcept;
+constexpr T operator=(T desired) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Returns:* `desired`.
 ``` cpp
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
+constexpr T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `this`.
 ``` cpp
 operator T() const volatile noexcept;
+constexpr operator T() const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return load();`
 ``` cpp
 T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 before the effects.
 ``` cpp
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) volatile noexcept;
+constexpr bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) volatile noexcept;
+constexpr bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) noexcept;
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value pointed to by `this` for
 equality with that previously retrieved from `expected`, and if true,
 replaces the value pointed to by `this` with that in `desired`. If and
 [*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
 compare-and-exchange operations apply, the comparisons can fail for
 values that compare equal with `operator==` if the value representation
 has trap bits or alternate representations of the same value. Notably,
+on implementations conforming to ISO/IEC 60559, floating-point `-0.0`
+and `+0.0` will not compare equal with `memcmp` but will compare equal
+with `operator==`, and NaNs with the same payload will compare equal
+with `memcmp` but will not compare equal with
 `operator==`. — *end note*]
 [*Note 7*:
 Because compare-and-exchange acts on an object’s value representation,
 — *end note*]
 ``` cpp
 void wait(T old, memory_order order = memory_order::seq_cst) const volatile noexcept;
+constexpr void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
 *Remarks:* This function is an atomic waiting
 operation [[atomics.wait]].
 ``` cpp
 void notify_one() volatile noexcept;
+constexpr void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
 void notify_all() volatile noexcept;
+constexpr void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(integral-type, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(integral-type, memory_order = memory_order::seq_cst) noexcept;
     integral-type operator=(integral-type) volatile noexcept;
+ constexpr integral-type operator=(integral-type) noexcept;
     integral-type load(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr integral-type load(memory_order = memory_order::seq_cst) const noexcept;
     operator integral-type() const volatile noexcept;
+ constexpr operator integral-type() const noexcept;
     integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_xor(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_max(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr integral-type fetch_max(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_min(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr integral-type fetch_min(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    void store_add(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_add(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_sub(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_sub(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_and(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_and(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_or(integral-type,
+                  memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_or(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    void store_xor(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_xor(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_max(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_max(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_min(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_min(integral-type,
                              memory_order = memory_order::seq_cst) noexcept;
     integral-type operator++(int) volatile noexcept;
+ constexpr integral-type operator++(int) noexcept;
     integral-type operator--(int) volatile noexcept;
+ constexpr integral-type operator--(int) noexcept;
     integral-type operator++() volatile noexcept;
+ constexpr integral-type operator++() noexcept;
     integral-type operator--() volatile noexcept;
+ constexpr integral-type operator--() noexcept;
     integral-type operator+=(integral-type) volatile noexcept;
+ constexpr integral-type operator+=(integral-type) noexcept;
     integral-type operator-=(integral-type) volatile noexcept;
+ constexpr integral-type operator-=(integral-type) noexcept;
     integral-type operator&=(integral-type) volatile noexcept;
+ constexpr integral-type operator&=(integral-type) noexcept;
     integral-type operator|=(integral-type) volatile noexcept;
+ constexpr integral-type operator|=(integral-type) noexcept;
     integral-type operator^=(integral-type) volatile noexcept;
+ constexpr integral-type operator^=(integral-type) noexcept;
     void wait(integral-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The atomic integral specializations are standard-layout structs. They
 [[atomic.types.int.comp]].
 **Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
 |       |     |             |       |     |                      |
+| ----- | --- | ----------- | ----- | --- | -------------------- |
+| `add` | `+` | addition | `and` | `&` | bitwise and          |
+| `sub` | `-` | subtraction | `or` | `|` | bitwise inclusive or |
+| `max` |     | maximum     | `xor` | `^` | bitwise exclusive or |
+| `min` |     | minimum     |       |     |                      |
 ``` cpp
+integral-type fetch_key(integral-type operand,
+ memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr integral-type fetch_key(integral-type operand,
+                                   memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 operations [[intro.multithread]].
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
+*Remarks:* Except for `fetch_max` and `fetch_min`, for signed integer
+types the result is as if the object value and parameters were converted
+to their corresponding unsigned types, the computation performed on
+those types, and the result converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
 ``` cpp
+void store_key(integral-type operand,
+                memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store_key(integral-type operand,
+                          memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* Except for `store_max` and `store_min`, for signed integer
+types, the result is as if the value pointed to by `this` and parameters
+were converted to their corresponding unsigned types, the computation
+performed on those types, and the result converted back to the signed
+type.
+[*Note 2*: There are no undefined results arising from the
+computation. — *end note*]
+For `store_max` and `store_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the value pointed to by `this` and the first
+parameter as the arguments.
+``` cpp
+integral-type operator op=(integral-type operand) volatile noexcept;
+constexpr integral-type operator op=(integral-type operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator=(floating-point-type) volatile noexcept;
+ constexpr floating-point-type operator=(floating-point-type) noexcept;
     floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
     operator floating-point-type() volatile noexcept;
+ constexpr operator floating-point-type() noexcept;
     floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type exchange(floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order, memory_order) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order, memory_order) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type fetch_add(floating-point-type,
                                             memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type fetch_sub(floating-point-type,
+                                            memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_max(floating-point-type,
+                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_max(floating-point-type,
+                                            memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_min(floating-point-type,
+                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-poin-typet fetch_min(floating-point-type,
+                                            memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fmaximum(floating-point-type,
+                                       memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fmaximum(floating-point-type,
+                                                 memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fminimum(floating-point-type,
+                                       memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fminimum(floating-point-type,
+                                                 memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fmaximum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fmaximum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fminimum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fminimum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+    void store_add(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_add(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_sub(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_sub(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_max(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_max(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_min(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_min(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_fmaximum(floating-point-type,
+                        memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fmaximum(floating-point-type,
+                                  memory_order = memory_order::seq_cst) noexcept;
+    void store_fminimum(floating-point-type,
+                        memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fminimum(floating-point-type,
+                                  memory_order = memory_order::seq_cst) noexcept;
+    void store_fmaximum_num(floating-point-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fmaximum_num(floating-point-type,
+                                      memory_order = memory_order::seq_cst) noexcept;
+    void store_fminimum_num(floating-point-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fminimum_num(floating-point-type,
                                       memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator+=(floating-point-type) volatile noexcept;
+ constexpr floating-point-type operator+=(floating-point-type) noexcept;
     floating-point-type operator-=(floating-point-type) volatile noexcept;
+ constexpr floating-point-type operator-=(floating-point-type) noexcept;
     void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(floating-point-type,
+                        memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The atomic floating-point specializations are standard-layout structs.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic addition and subtraction
 computations. The correspondence among key, operator, and computation is
+specified in [[atomic.types.int.comp]], except for the keys `max`,
+`min`, `fmaximum`, `fminimum`, `fmaximum_num`, and `fminimum_num`, which
+are specified below.
 ``` cpp
+floating-point-type fetch_key(floating-point-type operand,
+ memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr floating-point-type fetch_key(floating-point-type operand,
+                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
 *`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
+- For `fetch_fmaximum` and `fetch_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with the value pointed to by `this` and the first
+  parameter as the arguments.
+- For `fetch_fmaximum_num` and `fetch_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num` and
+  `fminimum_num`, respectively, with the value pointed to by `this` and
+  the first parameter as the arguments.
+- For `fetch_max` and `fetch_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with the value pointed to by `this` and the first parameter as the
+  arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value replaces the
+    value pointed to by `this`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value replaces the value pointed to by `this`; it is
+    unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    replaces the value pointed to by this is unspecified.
+*Recommended practice:* The implementation of `fetch_max` and
+`fetch_min` should treat negative zero as smaller than positive zero.
 ``` cpp
+void store_key(floating-point-type operand,
+               memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store_key(floating-point-type operand,
+                         memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given operand. Memory is affected according to the value of `order`.
+These operations are atomic modify-write operations [[atomics.order]].
+*Remarks:* If the result is not a representable value for its
+type [[expr.pre]] the result is unspecified, but the operations
+otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`numeric_limits<`*`floating-point-type`*`>` traits associated with the
+floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
+floating-point environment. The arithmetic rules of floating-point
+atomic modify-write operations may be different from operations on
+floating-point types or atomic floating-point types.
+[*Note 1*: Tree reductions are permitted for atomic modify-write
+operations. — *end note*]
+- For `store_fmaximum` and `store_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with the value pointed to by `this` and the first
+  parameter as the arguments.
+- For `store_fmaximum_num` and `store_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num` and
+  `fminimum_num`, respectively, with the value pointed to by `this` and
+  the first parameter as the arguments.
+- For `store_max` and `store_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with the value pointed to by `this` and the first parameter as the
+  arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value replaces the
+    value pointed to by `this`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value replaces the value pointed to by `this`; it is
+    unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    replaces the value pointed to by `this` is unspecified.
+*Recommended practice:* The implementation of `store_max` and
+`store_min` should treat negative zero as smaller than positive zero.
+``` cpp
+floating-point-type operator op=(floating-point-type operand) volatile noexcept;
+constexpr floating-point-type operator op=(floating-point-type operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(T*, memory_order = memory_order::seq_cst) noexcept;
     T* operator=(T*) volatile noexcept;
+ constexpr T* operator=(T*) noexcept;
     T* load(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr T* load(memory_order = memory_order::seq_cst) const noexcept;
     operator T*() const volatile noexcept;
+ constexpr operator T*() const noexcept;
     T* exchange(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T* exchange(T*, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) noexcept;
     T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
     T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    T* fetch_max(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr T* fetch_max(T*, memory_order = memory_order::seq_cst) noexcept;
+    T* fetch_min(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr T* fetch_min(T*, memory_order = memory_order::seq_cst) noexcept;
+    void store_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    void store_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    void store_max(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_max(T*, memory_order = memory_order::seq_cst) noexcept;
+    void store_min(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_min(T*, memory_order = memory_order::seq_cst) noexcept;
     T* operator++(int) volatile noexcept;
+ constexpr T* operator++(int) noexcept;
     T* operator--(int) volatile noexcept;
+ constexpr T* operator--(int) noexcept;
     T* operator++() volatile noexcept;
+ constexpr T* operator++() noexcept;
     T* operator--() volatile noexcept;
+ constexpr T* operator--() noexcept;
     T* operator+=(ptrdiff_t) volatile noexcept;
+ constexpr T* operator+=(ptrdiff_t) noexcept;
     T* operator-=(ptrdiff_t) volatile noexcept;
+ constexpr T* operator-=(ptrdiff_t) noexcept;
     void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 There is a partial specialization of the `atomic` class template for
 **Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
 |       |     |          |       |     |             |
 | ----- | --- | -------- | ----- | --- | ----------- |
 | `add` | `+` | addition | `sub` | `-` | subtraction |
+| `max` |     | maximum  | `min` |     | minimum     |
 ``` cpp
+T* fetch_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr T* fetch_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
+[*Note 2*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
+``` cpp
+void store_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Mandates:* `T` is a complete object type.
+[*Note 3*: Pointer arithmetic on `void*` or function pointers is
+ill-formed. — *end note*]
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* The result may be an undefined address, but the operations
+otherwise have no undefined behavior. For `store_max` and `store_min`,
+the maximum and minimum computation is performed as if by `max` and
+`min` algorithms [[alg.min.max]], respectively, with the value pointed
+to by `this` and the first parameter as the arguments.
+[*Note 4*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
 ``` cpp
 T* operator op=(ptrdiff_t operand) volatile noexcept;
+constexpr T* operator op=(ptrdiff_t operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 #### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
 value_type operator++(int) volatile noexcept;
+constexpr value_type operator++(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
 value_type operator--(int) volatile noexcept;
+constexpr value_type operator--(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
 value_type operator++() volatile noexcept;
+constexpr value_type operator++() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
 value_type operator--() volatile noexcept;
+constexpr value_type operator--() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
     constexpr atomic(nullptr_t) noexcept : atomic() { }
+ constexpr atomic(shared_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
+ constexpr shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr operator shared_ptr<T>() const noexcept;
+ constexpr void store(shared_ptr<T> desired,
+                         memory_order order = memory_order::seq_cst) noexcept;
+    constexpr void operator=(shared_ptr<T> desired) noexcept;
+    constexpr void operator=(nullptr_t) noexcept;
+ constexpr shared_ptr<T> exchange(shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
+ constexpr void wait(shared_ptr<T> old,
+                        memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() noexcept;
+    constexpr void notify_all() noexcept;
   private:
     shared_ptr<T> p;            // exposition only
   };
 }
 ``` cpp
 constexpr atomic() noexcept;
 ```
+*Effects:* Value-initializes `p`.
 ``` cpp
+constexpr atomic(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
+constexpr void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
+constexpr void operator=(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
+constexpr void operator=(nullptr_t) noexcept;
 ```
+*Effects:* Equivalent to `store(nullptr)`.
+``` cpp
+constexpr shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
+constexpr operator shared_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
+constexpr shared_ptr<T> exchange(shared_ptr<T> desired,
+                                 memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
+constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
+constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
+constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
 *Remarks:* Two `shared_ptr` objects are equivalent if they store the
 same pointer and either share ownership or are both empty. This function
 is an atomic waiting operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
+ constexpr atomic(weak_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
+ constexpr weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr operator weak_ptr<T>() const noexcept;
+ constexpr void store(weak_ptr<T> desired,
+                         memory_order order = memory_order::seq_cst) noexcept;
+    constexpr void operator=(weak_ptr<T> desired) noexcept;
+ constexpr weak_ptr<T> exchange(weak_ptr<T> desired,
                                    memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
+ constexpr void wait(weak_ptr<T> old,
+                        memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() noexcept;
+    constexpr void notify_all() noexcept;
   private:
     weak_ptr<T> p;              // exposition only
   };
 }
 ``` cpp
 constexpr atomic() noexcept;
 ```
+*Effects:* Value-initializes `p`.
 ``` cpp
+constexpr atomic(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
+constexpr void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
+constexpr void operator=(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
+constexpr weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
+constexpr operator weak_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
+constexpr weak_ptr<T> exchange(weak_ptr<T> desired,
+                               memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
+constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
+constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
+constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
 *Remarks:* Two `weak_ptr` objects are equivalent if they store the same
 pointer and either share ownership or are both empty. This function is
 an atomic waiting operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.

Diff to HTML by rtfpessoa