Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | memory‎ | shared ptr
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
std::shared_ptr
Memberfunktionen
Modifizierer
Observer
(C++17)
(bis C++20*)
(C++26)
(C++26)
Nicht-Member-Funktionen
(C++20)
(C++20)
(C++17)
(bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20)
atomic_xxx
funktionen (bis C++26*)
Hilfsklassen
(C++20)
Deduktionsleitfäden(C++17)
 
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ührungsfäden gleichzeitig auf dasselbe std::shared_ptr Objekt ohne Synchronisation zugreifen und einer dieser Zugriffe eine nicht-const-Memberfunktion von shared_ptr verwendet, tritt ein Datenrennen auf, es sei denn, alle solchen Zugriffe erfolgen über diese Funktionen, die Überladungen der entsprechenden atomaren Zugriffsfunktionen sind (std::atomic_load, std::atomic_store, etc.).

Beachten Sie, dass der Kontrollblock eines shared_ptr threadsicher ist: Unterschiedliche std::shared_ptr Objekte können gleichzeitig von mehreren Threads über veränderliche Operationen wie operator= oder reset zugegriffen werden, auch wenn diese Instanzen Kopien sind und intern denselben Kontrollblock gemeinsam nutzen.

1) Bestimmt, ob der atomare Zugriff auf den von p zeigenden gemeinsamen Zeiger sperrfrei ist.
2) Äquivalent zu atomic_load_explicit(p, std::memory_order_seq_cst).
3) Gibt den von p zeigenden gemeinsamen Zeiger zurück.
Wie bei der nicht spezialisierten std::atomic_load_explicit, wenn mo std::memory_order_release oder std::memory_order_acq_rel ist, ist das Verhalten undefiniert.
4) Äquivalent zu atomic_store_explicit(p, r, std::memory_order_seq_cst).
5) Speichert den gemeinsamen Zeiger r atomar im gemeinsamen Zeiger, auf den p zeigt, als ob durch p->swap(r).
Wie bei der nicht spezialisierten std::atomic_store_explicit, wenn mo std::memory_order_acquire oder std::memory_order_acq_rel ist, ist das Verhalten undefiniert.
6) Äquivalent zu atomic_exchange_explicit(p, r, std::memory_order_seq_cst).
7) Speichert den gemeinsamen Zeiger r im gemeinsamen Zeiger, auf den p zeigt, und gibt den zuvor von p zeigenden Wert zurück, atomar, als ob durch p->swap(r) und gibt eine Kopie von r nach dem Austausch zurück.
8) Äquivalent zu
atomic_compare_exchange_weak_explicit
    (p, expected, desired, std::memory_order_seq_cst,
                           std::memory_order_seq_cst).
9) Äquivalent zu
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 zeigenden gemeinsamen Zeiger.
  • Wenn sie äquivalent sind (den gleichen Zeigerwert speichern und entweder den Besitz desselben Objekts gemeinsam nutzen oder beide leer sind), weist desired unter Verwendung der von success angegebenen Speicherreihenfolgenbeschränkungen in *p zu und gibt true zurück.
  • Wenn sie nicht äquivalent sind, weist *p unter Verwendung der von failure angegebenen Speicherreihenfolgenbeschränkungen in *expected zu und gibt false zurück.
atomic_compare_exchange_weak_explicit kann fehlerhaft fehlschlagen.
Wenn expected ein Nullzeiger ist oder failure std::memory_order_release oder std::memory_order_acq_rel ist, ist das Verhalten undefiniert.

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

Inhalt

[edit] Parameter

p, expected - Ein Zeiger auf einen std::shared_ptr
r, desired - Ein std::shared_ptr
mo, success, failure - Speicherreihenfolgen-Selektoren vom Typ std::memory_order

[edit] Ausnahmen

Diese Funktionen werfen keine Ausnahmen.

[edit] Rückgabewert

1) true, wenn der atomare Zugriff mit sperrfreien Anweisungen implementiert ist.
2,3) Eine Kopie des zeigenden gemeinsamen Zeigers.
4,5) (keine)
6,7) Eine Kopie des zuvor zeigenden gemeinsamen Zeigers.
8-11) true, wenn die gemeinsamen Zeiger äquivalent waren und der Austausch durchgeführt wurde, false andernfalls.

[edit] Hinweise

Diese Funktionen werden typischerweise mithilfe von Mutexen implementiert, die in einer globalen Hashtabelle gespeichert sind, wobei der Zeigerwert als Schlüssel verwendet wird.

Die 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 veraltet: 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)

[edit] Beispiel

Dieser Abschnitt ist unvollständig
Grund: kein Beispiel

[edit] Fehlerberichte

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2172 C++11 expected konnte ein Nullzeiger sein das Verhalten ist in diesem Fall undefiniert
LWG 2980 C++11 leere shared_ptr waren nie äquivalent äquivalent, wenn sie den gleichen Zeigerwert speichern

[edit] Siehe auch

(C++11)
 prüft, ob die Operationen des atomaren Typs sperrfrei sind
(Funktions-Template) [bearbeiten]
(C++11)(C++11)
 ersetzt atomar den Wert des atomaren Objekts durch ein nicht-atomares Argument
(Funktions-Template) [bearbeiten]
(C++11)(C++11)
 liest atomar den Wert aus einem atomaren Objekt
(Funktions-Template) [bearbeiten]
(C++11)(C++11)
 ersetzt atomar den Wert des atomaren Objekts durch ein nicht-atomares Argument und gibt den alten Wert des atomaren Objekts zurück
(Funktions-Template) [bearbeiten]
(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 oder bei Ungleichheit eine atomare Ladeoperation durch
(Funktions-Template) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/shared_ptr/atomic&oldid=178235"