std::atomic<std::weak_ptr>

atomic<weak_ptr<T>>::atomic

constexpr atomic() noexcept = default;

atomic( std::weak_ptr<T> desired ) noexcept;

atomic( const atomic& ) = delete;

atomic<weak_ptr<T>>::operator=

void operator=( const atomic& ) = delete;

void operator=( std::weak_ptr<T> desired ) noexcept;

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;

Атомарно заменяет значение *this значением desired, как если бы выполнялось p.swap(desired), где 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;

Атомарно заменяет базовый std::weak_ptr<T> значением desired, как если бы выполнялось p.swap(desired), где 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;

bool compare_exchange_weak
    ( std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
      std::memory_order success, std::memory_order failure ) noexcept;

bool compare_exchange_strong
    ( std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
      std::memory_order order = std::memory_order_seq_cst ) noexcept;

bool compare_exchange_weak
    ( std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
      std::memory_order order = std::memory_order_seq_cst ) noexcept;

• В случае успеха операция является атомарной операцией чтения-модификации-записи над *this, и после атомарного обновления к expected больше не обращаются.
• В случае неудачи операция является атомарной операцией загрузки над *this, а expected обновляется значением, считанным из атомарного объекта. Это обновление use_count объекта expected является частью данной атомарной операции, хотя сама запись (и любое последующее освобождение памяти или уничтожение) не обязана быть её частью.

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, поведение не определено.

Примечание: два объекта std::weak_ptr эквивалентны, если они хранят один и тот же указатель и либо разделяют владение, либо оба пусты.

atomic<weak_ptr<T>>::notify_one

void notify_one() noexcept;

Выполняет атомарную операцию уведомления.

Если какой-либо поток заблокирован в ожидании атомарной операции (то есть выполняет wait()) на *this, разблокирует как минимум один такой поток; в противном случае ничего не делает.

atomic<weak_ptr<T>>::notify_all

void notify_all() noexcept;

Выполняет атомарную операцию уведомления.

Разблокирует все потоки, заблокированные в ожидании атомарной операции (то есть выполняющие wait()) на *this (если такие есть).

atomic<weak_ptr<T>>::is_always_lock_free

static constexpr bool is_always_lock_free = /* implementation-defined */;