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. See [atomics.types.operations].