[atomics.types.generic] - C++17 → C++20

Files changed (1) hide show

tmp/tmpu7v_j7ov/{from.md → to.md} +955 -195

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

@@ -2,113 +2,106 @@
 ``` cpp
 namespace std {
   template<class T> struct atomic {
     using value_type = T;
     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 volatile noexcept;
     bool is_lock_free() const noexcept;
-    void store(T, memory_order = memory_order_seq_cst) volatile noexcept;
- void store(T, memory_order = memory_order_seq_cst) 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;
- atomic() noexcept = default;
- constexpr atomic(T) noexcept;
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- T operator=(T) volatile noexcept;
-    T operator=(T) noexcept;
   };
 }
 ```
-The template argument for `T` shall be trivially copyable (
-[[basic.types]]).
 [*Note 1*: Type arguments that are not also statically initializable
 may 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 as its corresponding argument type. Specializations should
-have the same size whenever possible, as this reduces the effort
-required to port existing code. — *end note*]
 ### Operations on atomic types <a id="atomics.types.operations">[[atomics.types.operations]]</a>
-[*Note 1*: Many operations are volatile-qualified. The “volatile as
-device register” semantics have not changed in the standard. This
-qualification means that volatility is preserved when applying these
-operations to volatile objects. It does not mean that operations on
-non-volatile objects become volatile. — *end note*]
 ``` cpp
-atomic() noexcept = default;
 ```
-*Effects:* Leaves the atomic object in an uninitialized state.
-[*Note 1*: These semantics ensure compatibility with C. — *end note*]
 ``` cpp
 constexpr atomic(T desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
-Initialization is not an atomic operation ([[intro.multithread]]).
-[*Note 2*: It is possible to have an access to an atomic object `A`
 race with its construction, for example by communicating the address of
 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
-#define ATOMIC_VAR_INIT(value) see below
-```
-The macro expands to a token sequence suitable for constant
-initialization of an atomic variable of static storage duration of a
-type that is initialization-compatible with `value`.
-[*Note 3*: This operation may need to initialize locks. — *end note*]
-Concurrent access to the variable being initialized, even via an atomic
-operation, constitutes a data race.
-[*Example 1*:
-``` cpp
-atomic<int> v = ATOMIC_VAR_INIT(5);
-```
-— *end example*]
 ``` cpp
 static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
 ```
 The `static` data member `is_always_lock_free` is `true` if the atomic
 type’s operations are always lock-free, and `false` otherwise.
-[*Note 4*: The value of `is_always_lock_free` is consistent with the
 value of the corresponding `ATOMIC_..._LOCK_FREE` macro, if
 defined. — *end note*]
 ``` cpp
 bool is_lock_free() const volatile noexcept;
@@ -116,63 +109,79 @@ bool is_lock_free() const noexcept;
 ```
 *Returns:* `true` if the object’s operations are lock-free, `false`
 otherwise.
-[*Note 5*: The return value of the `is_lock_free` member function is
 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;
 ```
-*Requires:* The `order` argument shall not be `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;
 ```
-*Effects:* Equivalent to: `store(desired)`.
 *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;
 ```
-*Requires:* The `order` argument shall not be `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;
 ```
 *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;
 ```
 *Effects:* Atomically replaces the value pointed to by `this` with
 `desired`. Memory is affected according to the value of `order`. These
 operations are atomic read-modify-write
-operations ([[intro.multithread]]).
 *Returns:* Atomically returns the value pointed to by `this` immediately
 before the effects.
 ``` cpp
@@ -183,57 +192,60 @@ bool compare_exchange_weak(T& expected, T desired,
 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;
 ```
-*Requires:* The `failure` argument shall not be `memory_order_release`
-nor `memory_order_acq_rel`.
 *Effects:* Retrieves the value in `expected`. It then atomically
-compares the contents of the memory pointed to by `this` for equality
-with that previously retrieved from `expected`, and if true, replaces
-the contents of the memory pointed to by `this` with that in `desired`.
-If and only if the comparison is true, memory is affected according to
-the value of `success`, and if the comparison is false, memory is
-affected according to the value of `failure`. When only one
-`memory_order` argument is supplied, the value of `success` is `order`,
-and the value of `failure` is `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`. If and only if the
-comparison is false then, after the atomic operation, the contents of
-the memory in `expected` are replaced by the value read from the memory
-pointed to by `this` during the atomic comparison. If the operation
-returns `true`, these operations are atomic read-modify-write
-operations ([[intro.multithread]]) on the memory pointed to by `this`.
 Otherwise, these operations are atomic load operations on that memory.
 *Returns:* The result of the comparison.
-[*Note 6*:
-For example, the effect of `compare_exchange_strong` is
 ``` cpp
 if (memcmp(this, &expected, sizeof(*this)) == 0)
   memcpy(this, &desired, sizeof(*this));
 else
   memcpy(expected, this, sizeof(*this));
 ```
 — *end note*]
-[*Example 2*:
 The expected use of the compare-and-exchange operations is as follows.
 The compare-and-exchange operations will update `expected` when another
 iteration of the loop is needed.
@@ -244,16 +256,16 @@ do {
 } while (!current.compare_exchange_weak(expected, desired));
 ```
 — *end example*]
-[*Example 3*:
 Because the expected value is updated only on failure, code releasing
-the memory containing the `expected` value on success will work. E.g.
-list head insertion will act atomically and would not introduce a data
-race in the following code:
 ``` cpp
 do {
   p->next = head;                                   // make new list node point to the current head
 } while (!head.compare_exchange_weak(p->next, p));  // try to insert
@@ -269,90 +281,185 @@ the atomic object.
 *Remarks:* A weak compare-and-exchange operation may fail spuriously.
 That is, even when the contents of memory referred to by `expected` and
 `this` are equal, it may return `false` and store back to `expected` the
 same memory contents that were originally there.
-[*Note 7*: This spurious failure enables implementation of
 compare-and-exchange on a broader class of machines, e.g., load-locked
 store-conditional machines. A consequence of spurious failure is that
 nearly all uses of weak compare-and-exchange will be in a loop. When a
 compare-and-exchange is in a loop, the weak version will yield better
 performance on some platforms. When a weak compare-and-exchange would
 require a loop and a strong one would not, the strong one is
 preferable. — *end note*]
-[*Note 8*: The `memcpy` and `memcmp` semantics of the
-compare-and-exchange operations may result in failed comparisons for
-values that compare equal with `operator==` if the underlying type has
-padding bits, trap bits, or alternate representations of the same value.
-Thus, `compare_exchange_strong` should be used with extreme care. On the
-other hand, `compare_exchange_weak` should converge
-rapidly. — *end note*]
 ### Specializations for integers <a id="atomics.types.int">[[atomics.types.int]]</a>
-There are specializations of the `atomic` template for the integral
-types `char`, `signed char`, `unsigned char`, `short`, `unsigned short`,
-`int`, `unsigned int`, `long`, `unsigned long`, `long long`,
-`unsigned long long`, `char16_t`, `char32_t`, `wchar_t`, and any other
-types needed by the typedefs in the header `<cstdint>`. For each such
-integral type `integral`, the specialization `atomic<integral>` provides
-additional atomic operations appropriate to integral types.
-[*Note 1*: For the specialization `atomic<bool>`, see
 [[atomics.types.generic]]. — *end note*]
 ``` cpp
 namespace std {
   template<> struct atomic<integral> {
     using value_type = integral;
     using difference_type = value_type;
     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 volatile noexcept;
     bool is_lock_free() const noexcept;
-    void store(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    void store(integral, memory_order = memory_order_seq_cst) noexcept;
-    integral load(memory_order = memory_order_seq_cst) const volatile noexcept;
-    integral load(memory_order = memory_order_seq_cst) const noexcept;
-    operator integral() const volatile noexcept;
-    operator integral() const noexcept;
-    integral exchange(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    integral exchange(integral, memory_order = memory_order_seq_cst) noexcept;
-    bool compare_exchange_weak(integral&, integral,
-                               memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(integral&, integral,
-                               memory_order, memory_order) noexcept;
-    bool compare_exchange_strong(integral&, integral,
-                                 memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(integral&, integral,
-                                 memory_order, memory_order) noexcept;
-    bool compare_exchange_weak(integral&, integral,
-                               memory_order = memory_order_seq_cst) volatile noexcept;
-    bool compare_exchange_weak(integral&, integral,
-                               memory_order = memory_order_seq_cst) noexcept;
-    bool compare_exchange_strong(integral&, integral,
-                               memory_order = memory_order_seq_cst) volatile noexcept;
-    bool compare_exchange_strong(integral&, integral,
-                               memory_order = memory_order_seq_cst) noexcept;
-    integral fetch_add(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    integral fetch_add(integral, memory_order = memory_order_seq_cst) noexcept;
-    integral fetch_sub(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    integral fetch_sub(integral, memory_order = memory_order_seq_cst) noexcept;
-    integral fetch_and(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    integral fetch_and(integral, memory_order = memory_order_seq_cst) noexcept;
-    integral fetch_or(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    integral fetch_or(integral, memory_order = memory_order_seq_cst) noexcept;
-    integral fetch_xor(integral, memory_order = memory_order_seq_cst) volatile noexcept;
-    integral fetch_xor(integral, memory_order = memory_order_seq_cst) noexcept;
-    atomic() noexcept = default;
     constexpr atomic(integral) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     integral operator=(integral) volatile noexcept;
     integral operator=(integral) noexcept;
     integral operator++(int) volatile noexcept;
     integral operator++(int) noexcept;
     integral operator--(int) volatile noexcept;
     integral operator--(int) noexcept;
@@ -368,94 +475,256 @@ namespace std {
     integral operator&=(integral) noexcept;
     integral operator|=(integral) volatile noexcept;
     integral operator|=(integral) noexcept;
     integral operator^=(integral) volatile noexcept;
     integral operator^=(integral) noexcept;
   };
 }
 ```
 The atomic integral specializations are standard-layout structs. They
-each have a trivial default constructor and a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic computations. The key,
 operator, and computation correspondence is:
-**Table: Atomic arithmetic computations** <a id="tab:atomic.arithmetic.computations">[tab:atomic.arithmetic.computations]</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;
 ```
 *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 read-modify-write
-operations ([[intro.multithread]]).
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
-*Remarks:* For signed integer types, arithmetic is defined to use two’s
-complement representation. There are no undefined results.
 ``` cpp
 T operator op=(T operand) volatile noexcept;
 T operator op=(T operand) noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 ### Partial specialization for pointers <a id="atomics.types.pointer">[[atomics.types.pointer]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<T*> {
     using value_type = T*;
     using difference_type = ptrdiff_t;
     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 volatile noexcept;
     bool is_lock_free() const noexcept;
-    void store(T*, memory_order = memory_order_seq_cst) volatile noexcept;
- void store(T*, memory_order = memory_order_seq_cst) 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;
- atomic() noexcept = default;
- constexpr atomic(T*) noexcept;
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
-    atomic& operator=(const atomic&) volatile = delete;
-    T* operator=(T*) volatile noexcept;
-    T* operator=(T*) noexcept;
     T* operator++(int) volatile noexcept;
     T* operator++(int) noexcept;
     T* operator--(int) volatile noexcept;
     T* operator--(int) noexcept;
@@ -465,47 +734,55 @@ namespace std {
     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;
   };
 }
 ```
 There is a partial specialization of the `atomic` class template for
 pointers. Specializations of this partial specialization are
-standard-layout structs. They each have a trivial default constructor
-and a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform pointer arithmetic. The key, operator,
 and computation correspondence is:
-**Table: Atomic pointer computations** <a id="tab:atomic.pointer.computations">[tab:atomic.pointer.computations]</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;
 ```
-*Requires:* T shall be an object type, otherwise the program is
-ill-formed.
 [*Note 1*: 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 read-modify-write
-operations ([[intro.multithread]]).
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
@@ -514,38 +791,521 @@ otherwise have no undefined behavior.
 ``` cpp
 T* operator op=(ptrdiff_t operand) volatile noexcept;
 T* operator op=(ptrdiff_t operand) noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 ### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
-T operator++(int) volatile noexcept;
-T operator++(int) noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
-T operator--(int) volatile noexcept;
-T operator--(int) noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
-T operator++() volatile noexcept;
-T operator++() noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
-T operator--() volatile noexcept;
-T operator--() noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`

 ``` cpp
 namespace std {
   template<class T> struct atomic {
     using value_type = T;
     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 volatile noexcept;
     bool is_lock_free() const noexcept;
+ // [atomics.types.operations], operations on atomic types
+ constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
+ constexpr atomic(T) noexcept;
+    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*
+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
 may 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*]
 ### Operations on atomic types <a id="atomics.types.operations">[[atomics.types.operations]]</a>
 ``` 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
 constexpr atomic(T desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
+Initialization is not an atomic operation [[intro.multithread]].
+[*Note 1*: It is possible to have an access to an atomic object `A`
 race with its construction, for example by communicating the address of
 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
 static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
 ```
 The `static` data member `is_always_lock_free` is `true` if the atomic
 type’s operations are always lock-free, and `false` otherwise.
+[*Note 2*: The value of `is_always_lock_free` is consistent with the
 value of the corresponding `ATOMIC_..._LOCK_FREE` macro, if
 defined. — *end note*]
 ``` cpp
 bool is_lock_free() const volatile noexcept;
 ```
 *Returns:* `true` if the object’s operations are lock-free, `false`
 otherwise.
+[*Note 3*: The return value of the `is_lock_free` member function is
 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;
 ```
+*Preconditions:* The `order` argument is neither
+`memory_order::consume`, `memory_order::acquire`, nor
+`memory_order::acq_rel`.
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
 *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`.
+*Effects:* Equivalent to `store(desired)`.
 *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;
 ```
+*Preconditions:* The `order` argument is neither `memory_order::release`
+nor `memory_order::acq_rel`.
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
 *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`.
 *Effects:* Atomically replaces the value pointed to by `this` with
 `desired`. Memory is affected according to the value of `order`. These
 operations are atomic read-modify-write
+operations [[intro.multithread]].
 *Returns:* Atomically returns the value pointed to by `this` immediately
 before the effects.
 ``` cpp
 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;
 ```
+*Preconditions:* The `failure` argument is neither
+`memory_order::release` nor `memory_order::acq_rel`.
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
 *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
+only if the comparison is `true`, memory is affected according to the
+value of `success`, and if the comparison is false, memory is affected
+according to the value of `failure`. When only one `memory_order`
+argument is supplied, the value of `success` is `order`, and the value
+of `failure` is `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`. If and only if the comparison is false then,
+after the atomic operation, the value in `expected` is replaced by the
+value pointed to by `this` during the atomic comparison. If the
+operation returns `true`, these operations are atomic read-modify-write
+operations [[intro.multithread]] on the memory pointed to by `this`.
 Otherwise, these operations are atomic load operations on that memory.
 *Returns:* The result of the comparison.
+[*Note 4*:
+For example, the effect of `compare_exchange_strong` on objects without
+padding bits [[basic.types]] is
 ``` cpp
 if (memcmp(this, &expected, sizeof(*this)) == 0)
   memcpy(this, &desired, sizeof(*this));
 else
   memcpy(expected, this, sizeof(*this));
 ```
 — *end note*]
+[*Example 1*:
 The expected use of the compare-and-exchange operations is as follows.
 The compare-and-exchange operations will update `expected` when another
 iteration of the loop is needed.
 } while (!current.compare_exchange_weak(expected, desired));
 ```
 — *end example*]
+[*Example 2*:
 Because the expected value is updated only on failure, code releasing
+the memory containing the `expected` value on success will work. For
+example, list head insertion will act atomically and would not introduce
+a data race in the following code:
 ``` cpp
 do {
   p->next = head;                                   // make new list node point to the current head
 } while (!head.compare_exchange_weak(p->next, p));  // try to insert
 *Remarks:* A weak compare-and-exchange operation may fail spuriously.
 That is, even when the contents of memory referred to by `expected` and
 `this` are equal, it may return `false` and store back to `expected` the
 same memory contents that were originally there.
+[*Note 5*: This spurious failure enables implementation of
 compare-and-exchange on a broader class of machines, e.g., load-locked
 store-conditional machines. A consequence of spurious failure is that
 nearly all uses of weak compare-and-exchange will be in a loop. When a
 compare-and-exchange is in a loop, the weak version will yield better
 performance on some platforms. When a weak compare-and-exchange would
 require a loop and a strong one would not, the strong one is
 preferable. — *end note*]
+[*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
+compare-and-exchange operations apply, the outcome might be failed
+comparisons 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,
+padding bits that never participate in the object’s value representation
+are ignored. As a consequence, the following code is guaranteed to avoid
+spurious failure:
+``` cpp
+struct padded {
+  char clank = 0x42;
+  // Padding here.
+  unsigned biff = 0xC0DEFEFE;
+};
+atomic<padded> pad = {};
+bool zap() {
+  padded expected, desired{0, 0};
+  return pad.compare_exchange_strong(expected, desired);
+}
+```
+— *end note*]
+[*Note 8*:
+For a union with bits that participate in the value representation of
+some members but not others, compare-and-exchange might always fail.
+This is because such padding bits have an indeterminate value when they
+do not participate in the value representation of the active member. As
+a consequence, the following code is not guaranteed to ever succeed:
+``` cpp
+union pony {
+  double celestia = 0.;
+  short luna;       // padded
+};
+atomic<pony> princesses = {};
+bool party(pony desired) {
+  pony expected;
+  return princesses.compare_exchange_strong(expected, 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`.
+- If they compare unequal, returns.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*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.
+*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.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
 ### Specializations for integers <a id="atomics.types.int">[[atomics.types.int]]</a>
+There are specializations of the `atomic` class template for the
+integral types `char`, `signed char`, `unsigned char`, `short`,
+`unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
+`long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
+`wchar_t`, and any other types needed by the typedefs in the header
+`<cstdint>`. For each such type `integral`, the specialization
+`atomic<integral>` provides additional atomic operations appropriate to
+integral types.
+[*Note 1*: The specialization `atomic<bool>` uses the primary template
 [[atomics.types.generic]]. — *end note*]
 ``` cpp
 namespace std {
   template<> struct atomic<integral> {
     using value_type = integral;
     using difference_type = value_type;
     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 volatile noexcept;
     bool is_lock_free() const noexcept;
+ constexpr atomic() noexcept;
     constexpr atomic(integral) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
+    void store(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(integral, memory_order = memory_order::seq_cst) noexcept;
     integral operator=(integral) volatile noexcept;
     integral operator=(integral) noexcept;
+    integral load(memory_order = memory_order::seq_cst) const volatile noexcept;
+    integral load(memory_order = memory_order::seq_cst) const noexcept;
+    operator integral() const volatile noexcept;
+    operator integral() const noexcept;
+    integral exchange(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    integral exchange(integral, memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(integral&, integral,
+                               memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(integral&, integral,
+                               memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(integral&, integral,
+                                 memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(integral&, integral,
+                                 memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(integral&, integral,
+                               memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_weak(integral&, integral,
+                               memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(integral&, integral,
+                                 memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_strong(integral&, integral,
+                                 memory_order = memory_order::seq_cst) noexcept;
+    integral fetch_add(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    integral fetch_add(integral, memory_order = memory_order::seq_cst) noexcept;
+    integral fetch_sub(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    integral fetch_sub(integral, memory_order = memory_order::seq_cst) noexcept;
+    integral fetch_and(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    integral fetch_and(integral, memory_order = memory_order::seq_cst) noexcept;
+    integral fetch_or(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    integral fetch_or(integral, memory_order = memory_order::seq_cst) noexcept;
+    integral fetch_xor(integral, memory_order = memory_order::seq_cst) volatile noexcept;
+    integral fetch_xor(integral, memory_order = memory_order::seq_cst) noexcept;
     integral operator++(int) volatile noexcept;
     integral operator++(int) noexcept;
     integral operator--(int) volatile noexcept;
     integral operator--(int) noexcept;
     integral operator&=(integral) noexcept;
     integral operator|=(integral) volatile noexcept;
     integral operator|=(integral) noexcept;
     integral operator^=(integral) volatile noexcept;
     integral operator^=(integral) noexcept;
+    void wait(integral, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(integral, 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
+each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic computations. The key,
 operator, and computation correspondence is:
+**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`.
 *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 read-modify-write
+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`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+### Specializations for floating-point types <a id="atomics.types.float">[[atomics.types.float]]</a>
+There are specializations of the `atomic` class template for the
+floating-point types `float`, `double`, and `long double`. For each such
+type `floating-point`, the specialization `atomic<floating-point>`
+provides additional atomic operations appropriate to floating-point
+types.
+``` cpp
+namespace std {
+  template<> struct atomic<floating-point> {
+    using value_type = floating-point;
+    using difference_type = value_type;
+    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 volatile noexcept;
+    bool is_lock_free() const noexcept;
+    constexpr atomic() noexcept;
+    constexpr atomic(floating-point) noexcept;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+    void store(floating-point, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(floating-point, memory_order = memory_order::seq_cst) noexcept;
+    floating-point operator=(floating-point) volatile noexcept;
+    floating-point operator=(floating-point) noexcept;
+    floating-point load(memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point load(memory_order = memory_order::seq_cst) noexcept;
+    operator floating-point() volatile noexcept;
+    operator floating-point() noexcept;
+    floating-point exchange(floating-point,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point exchange(floating-point,
+                            memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(floating-point&, floating-point,
+                               memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(floating-point&, floating-point,
+                               memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(floating-point&, floating-point,
+                                 memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(floating-point&, floating-point,
+                                 memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(floating-point&, floating-point,
+                               memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_weak(floating-point&, floating-point,
+                               memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(floating-point&, floating-point,
+                                 memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_strong(floating-point&, floating-point,
+                                 memory_order = memory_order::seq_cst) noexcept;
+    floating-point fetch_add(floating-point,
+                             memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point fetch_add(floating-point,
+                             memory_order = memory_order::seq_cst) noexcept;
+    floating-point fetch_sub(floating-point,
+                             memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point fetch_sub(floating-point,
+                             memory_order = memory_order::seq_cst) noexcept;
+    floating-point operator+=(floating-point) volatile noexcept;
+    floating-point operator+=(floating-point) noexcept;
+    floating-point operator-=(floating-point) volatile noexcept;
+    floating-point operator-=(floating-point) noexcept;
+    void wait(floating-point, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(floating-point, 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.
+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 key, operator, and computation correspondence are
+identified 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`.
+*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 read-modify-write
+operations [[intro.multithread]].
+*Returns:* Atomically, the value pointed to by `this` immediately before
+the effects.
+*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`* should conform to the
+`std::numeric_limits<`*`floating-point`*`>` traits associated with the
+floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point`* 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`.
+*Effects:* Equivalent to:
+`return fetch_`*`key`*`(operand) `*`op`*` operand;`
+*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`* should conform to the
+`std::numeric_limits<`*`floating-point`*`>` traits associated with the
+floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point`* may be different than the calling thread’s
+floating-point environment.
 ### Partial specialization for pointers <a id="atomics.types.pointer">[[atomics.types.pointer]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<T*> {
     using value_type = T*;
     using difference_type = ptrdiff_t;
     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 volatile noexcept;
     bool is_lock_free() const noexcept;
+ constexpr atomic() noexcept;
+ constexpr atomic(T*) noexcept;
+ 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--() 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
 pointers. Specializations of this partial specialization are
+standard-layout structs. They each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform pointer arithmetic. The key, operator,
 and computation correspondence is:
+**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`.
+*Mandates:* `T` is a complete object type.
 [*Note 1*: 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 read-modify-write
+operations [[intro.multithread]].
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 ``` 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`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 ### 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`.
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
+### Partial specializations for smart pointers <a id="util.smartptr.atomic">[[util.smartptr.atomic]]</a>
+The library provides partial specializations of the `atomic` template
+for shared-ownership smart pointers [[smartptr]]. The behavior of all
+operations is as specified in [[atomics.types.generic]], unless
+specified otherwise. The template parameter `T` of these partial
+specializations may be an incomplete type.
+All changes to an atomic smart pointer in this subclause, and all
+associated `use_count` increments, are guaranteed to be performed
+atomically. Associated `use_count` decrements are sequenced after the
+atomic operation, but are not required to be part of it. Any associated
+deletion and deallocation are sequenced after the atomic update step and
+are not part of the atomic operation.
+[*Note 1*: If the atomic operation uses locks, locks acquired by the
+implementation will be held when any `use_count` adjustments are
+performed, and will not be held when any destruction or deallocation
+resulting from this is performed. — *end note*]
+[*Example 1*:
+``` cpp
+template<typename T> class atomic_list {
+  struct node {
+    T t;
+    shared_ptr<node> next;
+  };
+  atomic<shared_ptr<node>> head;
+public:
+  auto find(T t) const {
+    auto p = head.load();
+    while (p && p->t != t)
+      p = p->next;
+    return shared_ptr<node>(move(p));
+  }
+  void push_front(T t) {
+    auto p = make_shared<node>();
+    p->t = t;
+    p->next = head;
+    while (!head.compare_exchange_weak(p->next, p)) {}
+  }
+};
+```
+— *end example*]
+#### Partial specialization for `shared_ptr` <a id="util.smartptr.atomic.shared">[[util.smartptr.atomic.shared]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic<shared_ptr<T>> {
+    using value_type = shared_ptr<T>;
+    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(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
+  };
+}
+```
+``` 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]].
+[*Note 1*: It is possible to have an access to an atomic object `A`
+race with its construction, for example, by communicating the address of
+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`.
+*Returns:* `true` if `p` was equivalent to `expected`, `false`
+otherwise.
+*Remarks:* Two `shared_ptr` objects are equivalent if they store the
+same pointer value and either share ownership or are both empty. The
+weak form may fail spuriously. See [[atomics.types.operations]].
+If the operation returns `true`, `expected` is not accessed after the
+atomic update and the operation is an atomic read-modify-write
+operation [[intro.multithread]] on the memory pointed to by `this`.
+Otherwise, the operation is an atomic load operation on that memory, and
+`expected` is updated with the existing value read from the atomic
+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:
+``` cpp
+return compare_exchange_weak(expected, desired, order, fail_order);
+```
+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:
+``` cpp
+return compare_exchange_strong(expected, desired, order, fail_order);
+```
+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.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*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.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].
+#### Partial specialization for `weak_ptr` <a id="util.smartptr.atomic.weak">[[util.smartptr.atomic.weak]]</a>
+``` cpp
+namespace std {
+  template<class T> struct atomic<weak_ptr<T>> {
+    using value_type = weak_ptr<T>;
+    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
+  };
+}
+```
+``` 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]].
+[*Note 1*: It is possible to have an access to an atomic object `A`
+race with its construction, for example, by communicating the address of
+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`.
+*Returns:* `true` if `p` was equivalent to `expected`, `false`
+otherwise.
+*Remarks:* Two `weak_ptr` objects are equivalent if they store the same
+pointer value and either share ownership or are both empty. The weak
+form may fail spuriously. See [[atomics.types.operations]].
+If the operation returns `true`, `expected` is not accessed after the
+atomic update and the operation is an atomic read-modify-write
+operation [[intro.multithread]] on the memory pointed to by `this`.
+Otherwise, the operation is an atomic load operation on that memory, and
+`expected` is updated with the existing value read from the atomic
+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:
+``` cpp
+return compare_exchange_weak(expected, desired, order, fail_order);
+```
+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:
+``` cpp
+return compare_exchange_strong(expected, desired, order, fail_order);
+```
+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.
+- Blocks until it is unblocked by an atomic notifying operation or is
+  unblocked spuriously.
+*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.
+*Remarks:* This function is an atomic notifying
+operation [[atomics.wait]].

Diff to HTML by rtfpessoa