std::experimental::atomic_shared_ptr

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

Technical specifications

Filesystem library (filesystem TS)

Library fundamentals (library fundamentals TS)

Library fundamentals 2 (library fundamentals 2 TS)

Extensions for parallelism (parallelism TS)

Extensions for parallelism 2 (parallelism TS v2)

Extensions for concurrency (concurrency TS)

Concepts (concepts TS)

Ranges (ranges TS)

Special mathematical functions (special math TR)

Extensions for concurrency

std::future extensions

experimental::future

experimental::shared_future

experimental::when_all

experimental::when_any

experimental::make_ready_future

experimental::make_exceptional_future

Latches and barriers

experimental::latch

experimental::barrier

experimental::flex_barrier

Atomic smart pointers

experimental::atomic_shared_ptr

experimental::atomic_weak_ptr

std::experimental::atomic_shared_ptr

atomic_shared_ptr::atomic_shared_ptr

atomic_shared_ptr::operator=

atomic_shared_ptr::is_lock_free

atomic_shared_ptr::store

atomic_shared_ptr::load

atomic_shared_ptr::operator shared_ptr<T>

atomic_shared_ptr::exchange

atomic_shared_ptr::compare_exchange_weakatomic_shared_ptr::compare_exchange_strong

Defined in header <experimental/atomic>
template < class T > class atomic_shared_ptr;		(concurrency TS)

The class template atomic_shared_ptr provides thread-safe atomic pointer operations over a std::shared_ptr. It provides a better alternative to the non-member shared_ptr atomic access functions.

Member functions

(constructor)	constructs an atomic_shared_ptr object (public member function)
operator=	stores a value into an atomic_shared_ptr object (public member function)
is_lock_free	checks if the atomic_shared_ptr object is lock-free (public member function)
store	atomically replaces the value of the atomic object with a non-atomic argument (public member function)
load	atomically obtains the value of the atomic object (public member function)
operator shared_ptr<T>	loads a value from an atomic object (public member function)
exchange	atomically replaces the value of the atomic object and obtains the value held previously (public member function)
compare_exchange_weakcompare_exchange_strong	atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not (public member function)