Freigeben über

atomic Struktur

  • Artikel

Beschreibt ein Objekt, das Vorgänge für einen gespeicherten Wert vom Typ Tyausführtatomic.

Syntax

template <class Ty>
struct atomic;

Member

Member Beschreibung
Konstruktor
atomic Erstellt ein atomisches Objekt.
Operatoren
atomic::operator Ty Liest und den gespeicherten Wert und gibt ihn zurück. (atomic::load)
atomic::operator= Verwendet zum Ersetzen des gespeicherten Werts einen angegebenen Wert. (atomic::store)
atomic::operator++ Erhöht den gespeicherten Wert. Wird nur von integrale und Zeigerspezialisierungen verwendet.
atomic::operator+= Fügt dem gespeicherten Wert einen angegebenen Wert hinzu. Wird nur von integrale und Zeigerspezialisierungen verwendet.
atomic::operator-- Verringert den gespeicherten Wert. Wird nur von integrale und Zeigerspezialisierungen verwendet.
atomic::operator-= Subtrahiert einen angegebenen Wert vom gespeicherten Wert. Wird nur von integrale und Zeigerspezialisierungen verwendet.
atomic::operator&= Führt ein bitweises "and" (&) für einen angegebenen Wert und den gespeicherten Wert aus. Wird nur bei Integralspezialisierungen verwendet.
atomic::operator|= Führt ein bitweises "or" (|) für einen angegebenen Wert und den gespeicherten Wert aus. Wird nur bei Integralspezialisierungen verwendet.
atomic::operator^= Führt ein bitweises "exklusiv" oder (^) für einen angegebenen Wert und den gespeicherten Wert aus. Wird nur bei Integralspezialisierungen verwendet.
Funktionen
compare_exchange_strong Führt einen atomic_compare_and_exchange-Vorgang auf this aus und gibt das Ergebnis zurück.
compare_exchange_weak Führt einen weak_atomic_compare_and_exchange-Vorgang auf this aus und gibt das Ergebnis zurück.
fetch_add Fügt dem gespeicherten Wert einen angegebenen Wert hinzu.
fetch_and Führt ein bitweises "and" (&) für einen angegebenen Wert und den gespeicherten Wert aus.
fetch_or Führt ein bitweises "or" (|) für einen angegebenen Wert und den gespeicherten Wert aus.
fetch_sub Subtrahiert einen angegebenen Wert vom gespeicherten Wert.
fetch_xor Führt ein bitweises "exklusiv" oder (^) für einen angegebenen Wert und den gespeicherten Wert aus.
is_lock_free Gibt an, ob atomic Vorgänge this frei sind. Ein atomic Typ ist gesperrt , wenn keine atomic Vorgänge für diesen Typ Sperrungen verwenden.
load Liest und den gespeicherten Wert und gibt ihn zurück.
store Verwendet zum Ersetzen des gespeicherten Werts einen angegebenen Wert.

Hinweise

Der Ty-Typ muss einfach kopierbar sein. Das heißt, die Verwendung memcpy zum Kopieren seiner Bytes muss ein gültiges Ty Objekt erzeugen, das mit dem ursprünglichen Objekt verglichen wird. Mit den compare_exchange_weak Funktionen und compare_exchange_strong Membern memcmp können Sie bestimmen, ob zwei Ty Werte gleich sind. Diese Funktionen verwenden Tykeine -definierte operator==. Für die Memberfunktionen von atomic wird memcpy zum Kopieren der Werte des Typs Ty verwendet.

Eine teilweise Spezialisierung, atomic<Ty*>, ist für alle Zeigertypen vorhanden. Mit der Spezialisierung wird das Hinzufügen eines Offsets zum verwalteten Zeigerwert oder die Wegnahme eines Offsets von dort ermöglicht. Mit den arithmetischen Operationen wird ein Argument des Typs ptrdiff_t akzeptiert und entsprechend der Größe von Ty angepasst, damit es mit normaler Adressenarithmetik konsistent ist.

Eine Spezialisierung ist für jeden Integraltypen außer bool vorhanden. Mit jeder Spezialisierung wird ein umfangreicher Satz an Methoden für atomisch arithmetische und logische Vorgänge bereitgestellt.

atomic<char>
atomic<signed char>
atomic<unsigned char>
atomic<char16_t>
atomic<char32_t>
atomic<wchar_t>
atomic<short>

atomic<unsigned short>
atomic<int>
atomic<unsigned int>
atomic<long>
atomic<unsigned long>
atomic<long long>
atomic<unsigned long long>

Integralspezialisierungen werden von den entsprechenden atomic_integral-Typen abgeleitet. So wird atomic<unsigned int> z. B. von atomic_uint abgeleitet.

Anforderungen

Header: <atomic>

Namespace:std

atomic::atomic

Erstellt ein atomisches Objekt.

atomic();
atomic( const atomic& );
atomic( Ty Value ) noexcept;

Parameter

Value
Initialisierungswert

Hinweise

Atomobjekte können nicht kopiert oder verschoben werden.

Objekte, die atomic<Ty> Instanziierungen sind, können nur vom Konstruktor initialisiert werden, der ein Argument vom Typ Ty verwendet und nicht mithilfe der Aggregatinitialisierung. atomic_integral Objekte können jedoch nur mithilfe der Aggregatinitialisierung initialisiert werden.

atomic<int> ai0 = ATOMIC_VAR_INIT(0);
atomic<int> ai1(0);

atomic::operator Ty

Der Operator für den typ, der für die Vorlage angegeben ist, atomic<Ty>. Ruft den gespeicherten Wert in *this.

atomic<Ty>::operator Ty() const volatile noexcept;
atomic<Ty>::operator Ty() const noexcept;

Hinweise

Dieser Operator wendet die memory_order_seq_cst memory_order.

atomic::operator=

Speichert einen angegebenen Wert.

Ty operator=(
   Ty Value
) volatile noexcept;
Ty operator=(
   Ty Value
) noexcept;

Parameter

Value
Ein Ty-Objekt.

Rückgabewert

Gibt Value zurück.

atomic::operator++

Erhöht den gespeicherten Wert. Wird nur von integrale und Zeigerspezialisierungen verwendet.

Ty atomic<Ty>::operator++(int) volatile noexcept;
Ty atomic<Ty>::operator++(int) noexcept;
Ty atomic<Ty>::operator++() volatile noexcept;
Ty atomic<Ty>::operator++() noexcept;

Rückgabewert

Die ersten beiden Operatoren geben den inkrementierten Wert zurück. die letzten beiden Operatoren geben den Wert vor dem Inkrement zurück. Die Operatoren verwenden die memory_order_seq_cst memory_order.

atomic::operator+=

Fügt dem gespeicherten Wert einen angegebenen Wert hinzu. Wird nur von integrale und Zeigerspezialisierungen verwendet.

Ty atomic<Ty>::operator+=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator+=(
   Ty Value
) noexcept;

Parameter

Value
Ein integraler Oder Zeigerwert.

Rückgabewert

Ein Ty Objekt, das das Ergebnis des Hinzufügens enthält.

Hinweise

Dieser Operator verwendet die memory_order_seq_cst memory_order.

atomic::operator--

Verringert den gespeicherten Wert. Wird nur von integrale und Zeigerspezialisierungen verwendet.

Ty atomic<Ty>::operator--(int) volatile noexcept;
Ty atomic<Ty>::operator--(int) noexcept;
Ty atomic<Ty>::operator--() volatile noexcept;
Ty atomic<Ty>::operator--() noexcept;

Rückgabewert

Die ersten beiden Operatoren geben den dekrementierten Wert zurück. die letzten beiden Operatoren geben den Wert vor der Dekrementierung zurück. Die Operatoren verwenden die memory_order_seq_cst memory_order.

atomic::operator-=

Subtrahiert einen angegebenen Wert vom gespeicherten Wert. Wird nur von integrale und Zeigerspezialisierungen verwendet.

Ty atomic<Ty>::operator-=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator-=(
   Ty Value
) noexcept;

Parameter

Value
Ein integraler Oder Zeigerwert.

Rückgabewert

Ein Ty Objekt, das das Ergebnis der Subtraktion enthält.

Hinweise

Dieser Operator verwendet die memory_order_seq_cst memory_order.

atomic::operator&=

Führt ein bitweises "and" (&) für einen angegebenen Wert und den gespeicherten Wert von *this. Wird nur bei Integralspezialisierungen verwendet.

atomic<Ty>::operator&= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator&= (
   Ty Value
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Rückgabewert

Das Ergebnis des bitweisen "und" (&).

Hinweise

Dieser Operator führt einen Read-Modify-Write-Vorgang aus, um den gespeicherten Wert *this durch ein bitweises "and" (&) von Value und den aktuellen Wert zu ersetzen, der in *thisden Einschränkungen der memory_order_seq_cst memory_order.

atomic::operator|=

Führt ein bitweises "or" (|) für einen angegebenen Wert und den gespeicherten Wert von *this. Wird nur bei Integralspezialisierungen verwendet.

atomic<Ty>::operator|= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator|= (
   Ty Value
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Rückgabewert

Das Ergebnis des bitweisen "oder" (|).

Hinweise

Dieser Operator führt einen Lese-Modify-Write-Vorgang aus, um den gespeicherten Wert *this durch ein bitweises "oder" (|) von Value und den aktuellen Wert zu ersetzen, der in *thisden Einschränkungen der memory_order_seq_cst memory_order Einschränkungen gespeichert ist.

atomic::operator^=

Führt ein bitweises "exklusiv" oder (^) für einen angegebenen Wert und den gespeicherten Wert von *this. Wird nur bei Integralspezialisierungen verwendet.

atomic<Ty>::operator^= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator^= (
   Ty Value
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Rückgabewert

Das Ergebnis des bitweisen "exklusiv" oder (^).

Hinweise

Dieser Operator führt einen Read-Modify-Write-Vorgang aus, um den gespeicherten Wert *this durch einen bitweisen "exklusiv" oder (^) von Value und den aktuellen Wert zu ersetzen, der in *thisden Einschränkungen der memory_order_seq_cst memory_order Einschränkungen gespeichert ist.

atomic::compare_exchange_strong

Führt einen Atomabgleich und einen Austauschvorgang durch *this.

bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

Parameter

Exp
Ein Wert vom Typ Ty.

Value
Ein Wert vom Typ Ty.

Order1
Erstes memory_order Argument.

Order2
Zweites memory_order-Argument.

Rückgabewert

Ein das Ergebnis des Wertevergleichs angebendes bool-Element.

Hinweise

Dieser Atomabgleichs- und Austauschvorgang vergleicht den Wert, in *this Expdem gespeichert ist. Wenn die Werte gleich sind, ersetzt der Vorgang den Wert, der mit *this Value einem Lese-/Schreibvorgang gespeichert wird, und wendet die Durchschreibbedingungen für die Speicherreihenfolge an, die durch Order1angegeben werden. Wenn die Werte nicht gleich sind, verwendet der Vorgang den Wert, der zum *this Ersetzen Exp gespeichert ist, und wendet die einschränkungen für die Speicherreihenfolge an, die durch Order2angegeben werden.

Überladungen, die nicht über eine sekunde memory_order verfügen, verwenden eine implizite Order2 , die auf dem Wert von Order1. Falls Order1 den Wert memory_order_acq_rel hat, hat Order2 den Wert memory_order_acquire. Falls Order1 den Wert memory_order_release hat, hat Order2 den Wert memory_order_relaxed. In allen anderen Fällen Order2 ist gleich Order1.

Bei Überladungen, die zwei memory_order Parameter annehmen, darf der Wert nicht memory_order_release Order2 oder memory_order_acq_rel, und darf nicht stärker als der Wert von Order1sein.

atomic::compare_exchange_weak

Führt einen schwachen Atomabgleich und einen Austauschvorgang durch *this.

bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

Parameter

Exp
Ein Wert vom Typ Ty.

Value
Ein Wert vom Typ Ty.

Order1
Erstes memory_order Argument.

Order2
Zweites memory_order-Argument.

Rückgabewert

Ein das Ergebnis des Wertevergleichs angebendes bool-Element.

Hinweise

Dieser Atomabgleichs- und Austauschvorgang vergleicht den Wert, in *this Expdem gespeichert ist. Wenn die Werte gleich sind, ersetzt der Vorgang den Wert, der mit *this Value einem Lese-/Schreibvorgang gespeichert wird, und wendet die Durchschreibbedingungen für die Speicherreihenfolge an, die durch Order1angegeben werden. Wenn die Werte nicht gleich sind, verwendet der Vorgang den Wert, der zum *this Ersetzen Exp gespeichert ist, und wendet die einschränkungen für die Speicherreihenfolge an, die durch Order2angegeben werden.

Mit einem schwachen atomischen Vergleichs- und Austauschvorgang wird ein Austausch ausgeführt, wenn die verglichenen Werte gleich sind. Wenn die Werte nicht gleich sind, wird der Vorgang nicht garantiert, um einen Austausch durchzuführen.

Überladungen, die nicht über eine sekunde memory_order verfügen, verwenden eine implizite Order2 , die auf dem Wert von Order1. Falls Order1 den Wert memory_order_acq_rel hat, hat Order2 den Wert memory_order_acquire. Falls Order1 den Wert memory_order_release hat, hat Order2 den Wert memory_order_relaxed. In allen anderen Fällen Order2 ist gleich Order1.

Bei Überladungen, die zwei memory_order Parameter annehmen, darf der Wert nicht memory_order_release Order2 oder memory_order_acq_rel, und darf nicht stärker als der Wert von Order1sein.

atomic::exchange

Verwendet einen angegebenen Wert, um den gespeicherten Wert von *this.

Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Order
Ein memory_order.

Rückgabewert

Der gespeicherte Wert von *this vor dem Austausch.

Hinweise

Dieser Vorgang führt einen Lese-Modify-Write-Vorgang aus, um Value den wert zu ersetzen, der in *thisden speichereinschränkungen gespeichert ist, die durch Orderangegeben werden.

atomic::fetch_add

Ruft den in *thisgespeicherten Wert ab und fügt dann dem gespeicherten Wert einen angegebenen Wert hinzu.

Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Order
Ein memory_order.

Rückgabewert

Ein Ty Objekt, das den vor dem Hinzufügen gespeicherten *this Wert enthält.

Hinweise

Die fetch_add Methode führt einen Read-Modify-Write-Vorgang aus, um dem gespeicherten Wert *thisatomar hinzuzufügenValue, und wendet die speichereinschränkungen an, die durch Orderangegeben werden.

atomic::fetch_and

Führt ein bitweises "and" (&) für einen Wert und einen vorhandenen Wert aus, der in *this.

Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Order
Ein memory_order.

Rückgabewert

Ein Ty Objekt, das das Ergebnis des bitweisen "and" (&) enthält.

Hinweise

Die fetch_and Methode führt einen Lese-Modify-Write-Vorgang aus, um den gespeicherten Wert durch *this ein bitweises "and" (&) von Value und den aktuellen Wert zu ersetzen, der in *thisden speichereinschränkungen gespeichert ist, die durch Orderangegeben werden.

atomic::fetch_or

Führt ein bitweises "or" (|) für einen Wert und einen vorhandenen Wert aus, der in *this.

Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Order
Ein memory_order.

Rückgabewert

Ein Ty Objekt, das das Ergebnis des bitweisen "oder" (|) enthält.

Hinweise

Die fetch_or Methode führt einen Lese-Modify-Write-Vorgang aus, um den gespeicherten Wert *this durch ein bitweises "oder" (|) von Value und den aktuellen Wert zu ersetzen, der in *thisden speichereinschränkungen gespeichert ist, die durch Orderangegeben werden.

atomic::fetch_sub

Subtrahiert einen angegebenen Wert vom gespeicherten Wert.

Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Order
Ein memory_order.

Rückgabewert

Ein Ty Objekt, das das Ergebnis der Subtraktion enthält.

Hinweise

Die fetch_sub Methode führt einen Lese-Modify-Write-Vorgang aus, um den gespeicherten Wert in *this, innerhalb der durch angegebenen OrderSpeichereinschränkungen atomisch subtrahierenValue.

atomic::fetch_xor

Führt ein bitweises "exklusiv" oder (^) für einen Wert und einen vorhandenen Wert aus, der in *this.

Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Wert vom Typ Ty.

Order
Ein memory_order.

Rückgabewert

Ein Ty Objekt, das das Ergebnis des bitweisen "exklusiv" oder (^) enthält.

Hinweise

Die fetch_xor Methode führt einen Lese-Modify-Write-Vorgang aus, um den gespeicherten Wert *this durch einen bitweisen "exklusiv" oder (^) von Value und den aktuellen Wert zu ersetzen, in *thisdem gespeichert ist, und wendet die Speichereinschränkungen an, die durch Orderangegeben werden.

atomic::is_lock_free

Gibt an, ob atomic Vorgänge *this frei sind.

bool is_lock_free() const volatile noexcept;

Rückgabewert

true wenn atomic Vorgänge *this frei sind, andernfalls false.

Hinweise

Ein atomic Typ ist gesperrt, wenn keine atomic Vorgänge für diesen Typ Sperrungen verwenden.

atomic::load

Ruft den gespeicherten Wert in *this, innerhalb der angegebenen Speichereinschränkungen ab.

Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const volatile noexcept;
Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const noexcept;

Parameter

Order
Ein memory_order. Order darf nicht sein memory_order_release oder memory_order_acq_rel.

Rückgabewert

Der abgerufene Wert, der in *this-gespeichert wird.

atomic::store

Speichert einen angegebenen Wert.

void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parameter

Value
Ein Ty-Objekt.

Order
Eine memory_order Einschränkung.

Hinweise

Dieses Element wird atomisch in *thisden Speichereinschränkungen gespeichertValue, die durch Orderangegeben werden.

Siehe auch

<atomic>
Headerdateienreferenz