std::atomic(std::weak_ptr)

工具库

语言支持
类型支持（基本类型、 RTTI）
库功能特性测试宏 (C++20)
动态内存管理
程序工具
协程支持 (C++20)
变参数函数
is_constant_evaluated (C++20)
is_within_lifetime (C++26)
initializer_list (C++11)
source_location (C++20)
三路比较 (C++20)
three_way_comparablethree_way_comparable_with (C++20)(C++20)
strong_ordering (C++20)
weak_ordering (C++20)
partial_ordering (C++20)
common_comparison_category (C++20)
compare_three_way_result (C++20)
compare_three_way (C++20)
strong_order (C++20)
weak_order (C++20)
partial_order (C++20)
compare_strong_order_fallback (C++20)
compare_weak_order_fallback (C++20)
compare_partial_order_fallback (C++20)
is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

通用工具

日期和时间

函数对象

格式化库 (C++20)

bitset

hash

(C++11)

关系运算符 (C++20 中弃用)

rel_ops::operator!=rel_ops::operator>

rel_ops::operator<=rel_ops::operator>=

整数比较函数

cmp_equalcmp_lesscmp_less_than

(C++20)(C++20)(C++20)

cmp_not_equalcmp_greatercmp_greater_than

(C++20)(C++20)(C++20)

in_range

(C++20)

swap 与类型运算

swap
ranges::swap (C++20)
exchange (C++14)
declval (C++11)
to_underlying (C++23)

forward (C++11)
forward_like (C++23)
move (C++11)
move_if_noexcept (C++11)
as_const (C++17)

常用词汇类型

pair
tuple (C++11)
optional (C++17)
any (C++17)
variant (C++17)

tuple_size (C++11)
tuple_element (C++11)
apply (C++17)
make_from_tuple (C++17)
expected (C++23)

初等字符串转换

to_chars (C++17)
from_chars (C++17)
chars_format (C++17)

to_chars_result (C++17)
from_chars_result (C++17)

在标头 `<memory>` 定义
template <class T> struct std::atomic<std::weak_ptr<T>>;		(C++20 起)

std::atomic 对 std::weak_ptr<T> 的部分模板特化允许用户原子地操纵 weak_ptr 。

若多个执行线程访问同一 std::weak_ptr 对象而不同步，而任何这些访问使用 weak_ptr 的非 const 成员函数，则将出现数据竞争，除非所有这种访问都通过 std::atomic<std::weak_ptr>> 的实例进行。

保证关联 use_count 的自增是原子操作的一部分。要求关联 use_count 的自减在原子操作之后，但不要求是其一部分，除非在覆写失败的 CAS 中的 expected 时 use_count 更改。任何关联删除和解分配后序于原子更新步骤，且不是原子操作的一部分。

注意 std::weak_ptr 和 std::shared_ptr 所用的控制块是线程安全的：多个线程能同时用可变操作，例如 operator= 或 reset ，访问不同的非原子 std::weak_ptr 对象，即使在这些实例互为副本，或因其他原因于内部共享同一控制块时。

类型 T 可为不完整类型。

成员类型

成员类型	定义
`value_type`	std::weak_ptr<T>

成员函数

此特化亦提供所有非特化 std::atomic 的成员函数，且不提供额外成员函数。

atomic<weak_ptr<T>>::atomic

constexpr atomic() noexcept = default;	(1)
atomic(std::weak_ptr<T> desired) noexcept;	(2)
atomic(const atomic&) = delete;	(3)

1) 初始化底层 weak_ptr<T> 为默认构造值。

2) 初始化底层 weak_ptr<T> 为 desired 的副本。同任何 std::atomic ，初始化不是原子操作。

3) 原子类型不可复制/移动构造。

atomic<weak_ptr<T>>::operator=

void operator=(const atomic&) = delete;	(1)
void operator=(std::weak_ptr<T> desired) noexcept;	(2)

1) 原子类型不可复制/移动赋值。

2) 值赋值，等价于 store(desired)

atomic<weak_ptr<T>>::is_lock_free

bool is_lock_free() const noexcept;

若此类型所有对象上的原子操作为无锁则返回 true ，否则返回 false 。

atomic<weak_ptr<T>>::store

void store(std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept;

如同用 p.swap(desired) ，原子地以 desired 的值替换 *this 的值，其中 p 为底层的 std::weak_ptr<T> 。按照 order 排序内存。若 order 非 std::memory_order_consume 、 std::memory_order_acquire 或 std::memory_order_acq_rel 则行为未定义。

atomic<weak_ptr<T>>::load

std::weak_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept;

原子地返回底层 std::weak_ptr<T> 的副本。按照 order 排序内存。若 order 非 std::memory_order_release 或 std::memory_order_acq_rel 则行为未定义。

atomic<weak_ptr<T>>::operator std::weak_ptr<T>

operator std::weak_ptr<T>() const noexcept;

等价于 return load(); 。

atomic<weak_ptr<T>>::exchange

std::weak_ptr<T> exchange(std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept;

如同用 p.swap(desired) ，原子地以 desired 替换底层 std::weak_ptr<T> ，其中 p 为底层 std::weak_ptr<T> ，并返回 p 立即在交换前所拥有的值的副本。按照 order 排序内存。操作是原子读修改写操作。

atomic<weak_ptr<T>>::compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept;	(1)
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept;	(2)
bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept;	(3)
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept;	(4)

1) 若底层 std::weak_ptr<T> 存储值与 expected 相同的指针，并与之共享所有权，或若底层指针和 expected 均为空，则从 desired 赋值给底层 std::weak_ptr<T> 并返回 true ，按照 success 排序内存；否则从底层 std::weak_ptr<T> 赋值给 expected 并返回 false ，按照 failure 排序内存。若 failure 为 std::memory_order_release 或 std::memory_order_acq_rel 则行为未定义。成功时，操作为 *this 上的原子读修改写操作，而在原子更新后不访问 expected 。失败时，操作是 *this 上的原子加载操作，并以读取自原子对象的既存值更新 expected 。这个对 expected 的 use_count 的更新是原子操作，尽管不要求写入自身（和任何后继的解分配/析构）是。

2) 同 (1) ，但可能虚假地失败。

3) 等价于： return compare_exchange_strong(expected, desired, order, fail_order); ，其中 fail_order 与 order 相同，除了 std:memory_order_acq_rel 被替换为 std::memory_order_acquire ，而 std::memory_order_release 被替换为 std::memory_order_relaxed 。

4) 等价于： return compare_exchange_weak(expected, desired, order, fail_order); ，其中 fail_order 与 order 相同，除了 std::memory_order_acq_rel 被替换为 std::memory_order_acquire ，而 std::memory_order_release 被替换为 std::memory_order_relaxed 。

atomic<weak_ptr<T>>::wait

void wait(std::weak_ptr<T> old std::memory_order order = std::memory_order_seq_cst) const noexcept;

进行原子等待操作。

比较 load(order) 与 old ，而若它们等价则阻塞直至 *this 被 notify_one() 或 notify_all() 提醒。重复此操作直至 load(order) 更改。此函数保证仅若值更改才返回，即使底层实现虚假地除阻。

按照 order 排序内存。若 order 为 std::memory_order_release 或 std::memory_order_acq_rel 则行为未定义。

注解：若二个 weak_ptr 存储同一指针，且要么共享所有权要么都为空，则它们等价。

atomic<weak_ptr<T>>::notify_one

void notify_one() noexcept;

进行原子提醒操作。

若有一个线程在 *this 上的原子等待操作（即 wait() ）中阻塞，则除阻至少一个这种线程，否则不做任何事。

atomic<weak_ptr<T>>::notify_all

void notify_all() noexcept;