23 General utilities library [utilities]

23.11 Smart pointers [smartptr]

23.11.2 Shared-ownership pointers [util.smartptr]

23.11.2.6 shared_­ptr atomic access [util.smartptr.shared.atomic]

1
#
Concurrent access to a shared_­ptr object from multiple threads does not introduce a data race if the access is done exclusively via the functions in this section and the instance is passed as their first argument.
2
#
The meaning of the arguments of type memory_­order is explained in [atomics.order].
template<class T> bool atomic_is_lock_free(const shared_ptr<T>* p);
3
#
Requires: p shall not be null.
4
#
Returns: true if atomic access to *p is lock-free, false otherwise.
5
#
Throws: Nothing.
template<class T> shared_ptr<T> atomic_load(const shared_ptr<T>* p);
6
#
Requires: p shall not be null.
7
#
Returns: atomic_­load_­explicit(p, memory_­order_­seq_­cst).
8
#
Throws: Nothing.
template<class T> shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
9
#
Requires: p shall not be null.
10
#
Requires: mo shall not be memory_­order_­release or memory_­order_­acq_­rel.
11
#
Returns: *p.
12
#
Throws: Nothing.
template<class T> void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
13
#
Requires: p shall not be null.
14
#
Effects: As if by atomic_­store_­explicit(p, r, memory_­order_­seq_­cst).
15
#
Throws: Nothing.
template<class T> void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
16
#
Requires: p shall not be null.
17
#
Requires: mo shall not be memory_­order_­acquire or memory_­order_­acq_­rel.
18
#
Effects: As if by p->swap(r).
19
#
Throws: Nothing.
template<class T> shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
20
#
Requires: p shall not be null.
21
#
Returns: atomic_­exchange_­explicit(p, r, memory_­order_­seq_­cst).
22
#
Throws: Nothing.
template<class T> shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
23
#
Requires: p shall not be null.
24
#
Effects: As if by p->swap(r).
25
#
Returns: The previous value of *p.
26
#
Throws: Nothing.
template<class T> bool atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
27
#
Requires: p shall not be null and v shall not be null.
28
#
Returns: 
atomic_compare_exchange_weak_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
29
#
Throws: Nothing.
template<class T> bool atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
30
#
Returns: 
atomic_compare_exchange_strong_explicit(p, v, w, memory_order_seq_cst, memory_order_seq_cst)
template<class T> bool atomic_compare_exchange_weak_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure); template<class T> bool atomic_compare_exchange_strong_explicit( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w, memory_order success, memory_order failure);
31
#
Requires: p shall not be null and v shall not be null.
The failure argument shall not be memory_­order_­release nor memory_­order_­acq_­rel.
32
#
Effects: If *p is equivalent to *v, assigns w to *p and has synchronization semantics corresponding to the value of success, otherwise assigns *p to *v and has synchronization semantics corresponding to the value of failure.
33
#
Returns: true if *p was equivalent to *v, false otherwise.
34
#
Throws: Nothing.
35
#
Remarks: Two shared_­ptr objects are equivalent if they store the same pointer value and share ownership.
The weak form may fail spuriously.