std::atomic<std::shared_ptr>

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов(C++20)

Библиотека метапрограммирования(C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов(C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения(C++11)

Атомарные операции(C++11)

Библиотека поддержки конкуренции(C++11)

Библиотека файловой системы(C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Языковая поддержка Поддержка типов (базовые типы, 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 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)

 

Динамическое управление памятью

uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) voidify (C++20) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) Ограниченные алгоритмы неинициализированной памяти ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::construct_at (C++20) ranges::destroy (C++20) ranges::destroy_n (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::uninitialized_default_construct_n (C++20)   ranges::uninitialized_value_construct_n (C++20) allocator allocator_traits (C++11) allocation_result (C++23) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Ресурсы памяти pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17)   pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) Поддержка сбора мусора declare_reachable (C++11)(до C++23) undeclare_reachable (C++11)(до C++23) declare_no_pointers (C++11)(до C++23) undeclare_no_pointers (C++11)(до C++23) pointer_safety (C++11)(до C++23) get_pointer_safety (C++11)(до C++23) raw_storage_iterator (до C++20*) get_temporary_buffer (до C++20*) return_temporary_buffer (до C++20*) Явное управление временем жизни start_lifetime_asstart_lifetime_as_array (C++23)(C++23)

unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (до C++17*) owner_less (C++11) owner_less<void> (C++17) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler launder (C++17) bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) Библиотека C malloc calloc realloc    aligned_alloc (C++17) free

 

std::shared_ptr

Функции-элементы

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Модификаторы

shared_ptr::reset

shared_ptr::swap

Наблюдатели

shared_ptr::get

shared_ptr::operator*shared_ptr::operator->

shared_ptr::operator[] (C++17)

shared_ptr::use_count

shared_ptr::unique (до C++20*)

shared_ptr::operator bool

shared_ptr::owner_before

Функции, не являющиеся элементами

std::swap

make_sharedmake_shared_for_overwrite (C++20)

allocate_sharedallocate_shared_for_overwrite (C++20)

static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_pointer_cast (C++17)

get_deleter

operator==operator!=operator<operator<=operator>operator>=operator<=> (до C++20)(до C++20)(до C++20)(до C++20)(до C++20)(C++20)

operator<<

atomic_xxx functions (устарело в C++20)

std::atomic<std::shared_ptr> (C++20)

std::hash

Правила вывода(C++17)

 

Определено в заголовочном файле <memory>
template<class T > structstd::atomic<std::shared_ptr<T>>;		(начиная с C++20)

Частичная специализация шаблона std::atomic для std::shared_ptr<T> позволяет пользователям атомарно манипулировать объектами shared_ptr.

Если несколько потоков выполнения обращаются к одному и тому же объекту std::shared_ptr без синхронизации, и любой из этих доступов использует неконстантную функцию-элемент shared_ptr, тогда гонка данных не произойдёт, если только все такие доступы осуществляются через экземпляр std::atomic<std::shared_ptr> (или, что устарело в C++20, через автономные функции для атомарного доступа к std::shared_ptr).

Связанные инкременты use_count гарантированно являются частью атомарной операции. Связанные декременты use_count следуют за атомарной операцией, но не обязаны быть её частью, за исключением изменения use_count при переопределении expected в неудачном CAS. Любое связанное удаление и освобождение выполняются после шага атомарного обновления и не являются частью атомарной операции.

Обратите внимание, что блок управления shared_ptr является потокобезопасным: доступ к различным неатомарным объектам std::shared_ptr можно получить с помощью mutable операций, таких как operator = или reset одновременно нескольким потокам, даже если эти экземпляры являются копиями и совместно используют один и тот же внутренний блок управления.

Тип T может быть неполным типом.

Типы элементы

Тип элемент	Определение
value_type	std::shared_ptr<T>

Функции-элементы

Все неспециализированные функции std::atomic также предоставляются этой специализацией и не содержат дополнительных функций-элементов.

atomic<shared_ptr<T>>::atomic

constexpr atomic()noexcept=default;	(1)
constexpr atomic(std::nullptr_t)noexcept: atomic(){}	(2)
atomic(std::shared_ptr<T> desired )noexcept;	(3)
atomic(const atomic&)= delete;	(4)

1,2) Инициализирует базовый shared_ptr<T> нулевым значением.

3) Инициализирует базовый shared_ptr<T> копией desired. Как и в случае любого типа std::atomic, инициализация не является атомарной операцией.

4) Атомарные типы нельзя копировать/перемещать

atomic<shared_ptr<T>>::operator=

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

1) Атомарные типы нельзя копировать\перемещать присваиванием

2) Присваивание значения эквивалентно store(desired)

3) Сбрасывает атомарный общий указатель к нулевому значению указателя. Эквивалентно store(nullptr);.

atomic<shared_ptr<T>>::is_lock_free

bool is_lock_free()constnoexcept;

Возвращает true, если атомарные операции над всеми объектами этого типа не блокируются, иначе false.

atomic<shared_ptr<T>>::store

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

Атомарно заменяет значение *this значением desired, как если бы это было p.swap(desired), где p это базовый std::shared_ptr<T>. Память упорядочена в соответствии с order. Поведение не определено, если order равно std::memory_order_consume, std::memory_order_acquire или std::memory_order_acq_rel.

atomic<shared_ptr<T>>::load

std::shared_ptr<T> load(std::memory_order order =std::memory_order_seq_cst)constnoexcept;

Атомарно возвращает копию базового общего указателя. Память упорядочена в соответствии с order. Поведение не определено, если order равно std::memory_order_release или std::memory_order_acq_rel.

atomic<shared_ptr<T>>::operator std::shared_ptr<T>

operator std::shared_ptr<T>()constnoexcept;

Эквивалентно return load();

atomic<shared_ptr<T>>::exchange

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

Атомарно заменяет базовый std::shared_ptr<T> на desired, как если бы p.swap(desired), где p это базовый std::shared_ptr<T>, и возвращает копию значения, которое p имело непосредственно перед обменом. Память упорядочена в соответствии с order. Это атомарная операция чтения-изменения-записи.

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

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

1) Если базовый std::shared_ptr<T> хранит тот же T*, что и expected, и разделяет с ним владение, или если и базовый, и expected пусты, присваивает значение из desired базовому std::shared_ptr<T>, возвращает true и упорядочивает память в соответствии с success, иначе присваивает из базового std::shared_ptr<T> в expected, возвращает false и упорядочивает память в соответствии с failure. Поведение не определено, если failure равно std::memory_order_release или std::memory_order_acq_rel. В случае успеха операция является атомарной операцией чтения-изменения-записи для *this, а доступ к expected после атомарного обновления невозможен. В случае сбоя операция представляет собой атомарную операцию загрузки *this, а expected обновляется существующим значением, считанным из атомарного объекта. Это обновление use_count для expected является частью этой атомарной операции, хотя сама запись (и любое последующее освобождение/уничтожение) не требуется.

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<shared_ptr<T>>::wait

void wait(std::shared_ptr<T> old,            std::memory_order order =std::memory_order_seq_cst)constnoexcept;

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

Сравнивает load(order) с old и, если они эквивалентны, блокируется до тех пор, пока *this не будет уведомлён notify_one() или notify_all(). Это повторяется до тех пор, пока load(order) не изменится. Эта функция гарантированно возвращает значение, только если значение изменилось, даже если базовая реализация ложно разблокируется.

Память упорядочена в соответствии с order. Поведение не определено, если order равно std::memory_order_release или std::memory_order_acq_rel.

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

atomic<shared_ptr<T>>::notify_one

void notify_one()noexcept;

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

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

atomic<shared_ptr<T>>::notify_all

void notify_all()noexcept;

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

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

Константы элементы

Единственная стандартная константа-элемент std::atomic это is_always_lock_free, также предоставляемая этой специализацией.

atomic<shared_ptr<T>>::is_always_lock_free

staticconstexprbool is_always_lock_free =/*определено-реализацией*/;

Примечание

Макрос Тестирования функциональности	Значение	Стандарт	Функциональность
__cpp_lib_atomic_shared_ptr	201711L	(C++20)	std::atomic<std::shared_ptr>

Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 3661	C++20	atomic<shared_ptr<T>> не инициализировался константно из nullptr	сделан инициализируемым константно
LWG 3893	C++20	LWG3661 сделало atomic<shared_ptr<T>> недоступным для присваивания из nullptr_t	возможность присваивания восстановлена

Смотри также

atomic (C++11)

шаблон класса atomic и его специализации для bool, целочисленных типов и указателей (шаблон класса)