[ Web Proxy ]
URL:
Viewing: https://ru.cppreference.com/cpp/memory/shared_ptr/atomic2 [Back]  [Original]
std::atomic<std::shared_ptr> cppreference.com
cppreference.com

std::atomic<std::shared_ptr>

cppreference.com
 
C++
(C++20)
(C++20)
(C++11)
(C++20)
/
(C++11)
(C++11)
(C++11)
(C++17)
 
(C++20)
(C++11)
( C++20)
(C++20)(C++20)(C++20)    
(C++20)
(C++20)
(C++14)
(C++11)
(C++23)
(C++11)
(C++23)
(C++11)
(C++11)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++11)
(C++17)
(C++17)
(C++23)
(C++17)
(C++17)
(C++17)
 
no section name
no section name
(C++11)( C++23)
(C++11)( C++23)
(C++11)( C++23)
(C++11)( C++23)
(C++11)( C++23)
(C++11)( C++23)



no section name
( C++20*)
( C++20*)
( C++20*)
 
std::shared_ptr
 
<tbody> </tbody>
template< class T > struct std::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

<tbody> </tbody>
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=

<tbody> </tbody>
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

<tbody> </tbody>
bool is_lock_free() const noexcept;

true, , false.

atomic<shared_ptr<T>>::store

<tbody> </tbody>
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

<tbody> </tbody>
std::shared_ptr<T> load( std::memory_order order = std::memory_order_seq_cst ) const noexcept;

. order. , order std::memory_order_release std::memory_order_acq_rel.

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

<tbody> </tbody>
operator std::shared_ptr<T>() const noexcept;

return load();

atomic<shared_ptr<T>>::exchange

<tbody> </tbody>
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

<tbody> </tbody>
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

<tbody> </tbody>
void wait( std::shared_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.

: shared_ptr , , .

atomic<shared_ptr<T>>::notify_one

<tbody> </tbody>
void notify_one() noexcept;

.

, (.. wait()) *this, ; .

atomic<shared_ptr<T>>::notify_all

<tbody> </tbody>
void notify_all() noexcept;

.

, (.. wait()) *this, ; .

- std::atomic is_always_lock_free, .

atomic<shared_ptr<T>>::is_always_lock_free

<tbody> </tbody>
static constexpr bool 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

(C++11)
 atomic bool,
( ) []
Web Proxy Viewer  |  New URL  |  Original Page