Namespaces
Variants

std:: atomic_... <std::shared_ptr>

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::shared_ptr
Member functions
Modifiers
Observers
(C++17)
( until C++20* )
(C++26)
(C++26)
Non-member functions
(C++20)
(C++20)
(C++17)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
atomic_xxx
functions ( until C++26* )
Helper classes
(C++20)
Deduction guides (C++17)
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute gemäß den Anweisungen unverändert bleiben sollen und die Tabellenzellen leer sind.)
Definiert in Header <memory>
template < class T >
bool atomic_is_lock_free ( const std:: shared_ptr < T > * p ) ;
(1) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >
std:: shared_ptr < T > atomic_load ( const std:: shared_ptr < T > * p ) ;
(2) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

std:: shared_ptr < T > atomic_load_explicit

( const std:: shared_ptr < T > * p, std:: memory_order mo ) ;
(3) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >
void atomic_store ( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(4) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

void atomic_store_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > r,

std:: memory_order mo ) ;
(5) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange

( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(6) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > r,

std:: memory_order mo ) ;
(7) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

bool atomic_compare_exchange_weak
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,

std:: shared_ptr < T > desired ) ;
(8) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

bool atomic_compare_exchange_strong
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,

std:: shared_ptr < T > desired ) ;
(9) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

bool atomic_compare_exchange_strong_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,
std:: shared_ptr < T > desired,

std:: memory_order success, std:: memory_order failure ) ;
(10) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)
template < class T >

bool atomic_compare_exchange_weak_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,
std:: shared_ptr < T > desired,

std:: memory_order success, std:: memory_order failure ) ;
(11) (seit C++11)
(veraltet in C++20)
(entfernt in C++26)

Wenn mehrere Ausführungsstränge auf dasselbe std::shared_ptr -Objekt ohne Synchronisierung zugreifen und einer dieser Zugriffe eine nicht-konstante Memberfunktion von shared_ptr verwendet, tritt ein Datenwettlauf auf, es sei denn, alle derartigen Zugriffe erfolgen über diese Funktionen, bei denen es sich um Überladungen der entsprechenden atomaren Zugriffsfunktionen handelt ( std::atomic_load , std::atomic_store , etc.).

Beachten Sie, dass der Kontrollblock eines shared_ptr threadsicher ist: Unterschiedliche std::shared_ptr -Objekte können mit veränderbaren Operationen, wie operator = oder reset , gleichzeitig von mehreren Threads zugänglich gemacht werden, selbst wenn diese Instanzen Kopien sind und denselben Kontrollblock intern teilen.

1) Bestimmt, ob atomarer Zugriff auf den durch p gezeigten Shared Pointer sperrfrei ist.
2) Entspricht atomic_load_explicit ( p, std:: memory_order_seq_cst ) .
3) Gibt den durch p referenzierten Shared Pointer zurück.
Wie bei der nicht-spezialisierten std::atomic_load_explicit , ist das Verhalten undefiniert, wenn mo gleich std:: memory_order_release oder std:: memory_order_acq_rel ist.
4) Entspricht atomic_store_explicit ( p, r, std:: memory_order_seq_cst ) .
5) Speichert den Shared Pointer r atomar in den Shared Pointer, auf den p zeigt, als ob durch p - > swap ( r ) .
Wie bei der nicht-spezialisierten std::atomic_store_explicit , ist das Verhalten undefiniert, wenn mo gleich std:: memory_order_acquire oder std:: memory_order_acq_rel ist.
6) Entspricht atomic_exchange_explicit ( p, r, std:: memory_order_seq_cst ) .
7) Speichert den Shared Pointer r in dem Shared Pointer, auf den p zeigt, und gibt den zuvor von p gezeigten Wert atomar zurück, als ob durch p - > swap ( r ) und gibt eine Kopie von r nach dem Austausch zurück.
8) Entspricht
atomic_compare_exchange_weak_explicit
( p, expected, desired, std:: memory_order_seq_cst ,
std:: memory_order_seq_cst ) .
9) Entspricht
atomic_compare_exchange_strong_explicit
( p, expected, desired, std:: memory_order_seq_cst ,
std:: memory_order_seq_cst ) .
10,11) Vergleicht die von p und expected referenzierten Shared Pointer.
  • Wenn diese äquivalent sind (denselben Zeigerwert speichern und entweder denselben Objektbesitz teilen oder beide leer sind), weist desired unter Verwendung der durch success spezifizierten Speicherordnungsbeschränkungen in * p zu und gibt true zurück.
  • Wenn diese nicht äquivalent sind, weist * p unter Verwendung der durch failure spezifizierten Speicherordnungsbeschränkungen in * expected zu und gibt false zurück.
atomic_compare_exchange_weak_explicit kann sporadisch fehlschlagen.
Wenn expected ein Nullzeiger ist, oder failure gleich std:: memory_order_release oder std:: memory_order_acq_rel ist, ist das Verhalten undefiniert.

Wenn p ein Nullzeiger ist, ist das Verhalten dieser Funktionen allesamt undefiniert.

Inhaltsverzeichnis

Parameter

p, erwartet - ein Zeiger auf einen std::shared_ptr
r, gewünscht - ein std::shared_ptr
mo, Erfolg, Misserfolg - Speicherreihenfolge-Selektoren vom Typ std::memory_order

Exceptions

Diese Funktionen werfen keine Ausnahmen.

Rückgabewert

1) true wenn atomarer Zugriff mittels lock-freier Instruktionen implementiert ist.
2,3) Eine Kopie des gezeigten Shared Pointers.
4,5) (keine)
6,7) Eine Kopie des zuvor referenzierten Shared Pointers.
8-11) true falls die Shared Pointer äquivalent waren und der Austausch durchgeführt wurde, false andernfalls.

Hinweise

Diese Funktionen werden typischerweise mit Mutexen implementiert, die in einer globalen Hash-Tabelle gespeichert werden, wobei der Zeigerwert als Schlüssel verwendet wird.

Das Concurrency TS bietet atomare Smart-Pointer-Klassen atomic_shared_ptr und atomic_weak_ptr als Ersatz für die Verwendung dieser Funktionen.

Diese Funktionen wurden zugunsten der Spezialisierungen der std::atomic -Vorlage als veraltet markiert: std:: atomic < std:: shared_ptr > und std:: atomic < std:: weak_ptr > .

(seit C++20)
(bis C++26)

Diese Funktionen wurden zugunsten der Spezialisierungen der std::atomic -Vorlage entfernt: std:: atomic < std:: shared_ptr > und std:: atomic < std:: weak_ptr > .

(seit C++26)

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2172 C++11 expected könnte ein Nullzeiger sein das Verhalten ist in diesem Fall undefiniert
LWG 2980 C++11 leere shared_ptr s waren niemals äquivalent äquivalent wenn sie denselben Zeigerwert speichern

Siehe auch

(C++11)
prüft, ob die Operationen des atomaren Typs sperrfrei sind
(Funktions-Template)
(C++11) (C++11)
ersetzt atomar den Wert des atomaren Objekts mit einem nicht-atomaren Argument
(Funktions-Template)
(C++11) (C++11)
liest atomar den in einem atomaren Objekt gespeicherten Wert
(Funktions-Template)
(C++11) (C++11)
ersetzt atomar den Wert des atomaren Objekts mit einem nicht-atomaren Argument und gibt den alten Wert des atomaren Objekts zurück
(Funktions-Template)
(C++11) (C++11) (C++11) (C++11)
vergleicht atomar den Wert des atomaren Objekts mit einem nicht-atomaren Argument und führt bei Gleichheit einen atomaren Austausch durch, andernfalls einen atomaren Ladevorgang
(Funktions-Template)