Back to Qt.io
Contact Us Blog Download Qt
Auf dieser Seite

QAtomicScopedValueRollback Class

template <typename T> class QAtomicScopedValueRollback

Stellt eine „ QScopedValueRollback “ für atomare Variablen bereit. Mehr...

Header: #include <QAtomicScopedValueRollback>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Seit: Qt 6.7

Öffentliche Funktionen

QAtomicScopedValueRollback(QBasicAtomicInteger<T> &var, std::memory_order mo = std::memory_order_seq_cst)
QAtomicScopedValueRollback(QBasicAtomicPointer<std::remove_pointer_t<T>> &var, std::memory_order mo = std::memory_order_seq_cst)
QAtomicScopedValueRollback(std::atomic<T> &var, std::memory_order mo = std::memory_order_seq_cst)
QAtomicScopedValueRollback(QBasicAtomicInteger<T> &var, T value, std::memory_order mo = std::memory_order_seq_cst)
QAtomicScopedValueRollback(QBasicAtomicPointer<std::remove_pointer_t<T>> &var, T value, std::memory_order mo = std::memory_order_seq_cst)
QAtomicScopedValueRollback(std::atomic<T> &var, T value, std::memory_order mo = std::memory_order_seq_cst)
~QAtomicScopedValueRollback()
void commit()

Ausführliche Beschreibung

QAtomicScopedValueRollback<T> setzt eine atomare Variable vom Typ „ T “ bei ihrer Zerstörung auf ihren vorherigen Wert zurück. Diese Funktion kann verwendet werden, um den Zustand zurückzusetzen, wenn eine Ausnahme ausgelöst wird, ohne dass Try-Catch-Blöcke geschrieben werden müssen.

Sie kann auch zur Verwaltung von Variablen verwendet werden, die vorübergehend gesetzt werden, wie z. B. Reentrancy-Guards. Durch die Verwendung dieser Klasse wird die Variable zurückgesetzt, unabhängig davon, ob die Funktion normal beendet wird, vorzeitig durch eine return-Anweisung beendet wird oder durch eine Ausnahme beendet wird.

Die Klasse funktioniert mit std::atomic und den Qt-Atomic-Klassen: QBasicAtomicInteger, QAtomicInteger, QAtomicInt, QBasicAtomicPointer und QAtomicPointer.

Die Speicherzugriffe auf die atomare Variable ` var ` werden über den Wert von ` mo` festgelegt. Die Speicherreihenfolge folgt dieser Zuordnung: `
`

  • Beim Schreiben in die atomare Variable:
    • Führt eine „Acquire“-Reihenfolge stattdessen eine „Relaxed“-Operation durch.
    • Bei einer hybriden „Acquire-Release“-Reihenfolge wird stattdessen eine „Release“-Operation ausgeführt.
  • Beim Lesen aus der atomaren Variablen:
    • Führt eine „Release“-Reihenfolge stattdessen eine „Relaxed“-Operation durch.
    • Eine „Consume“-Reihenfolge führt eine „Consume“-Operation aus.
    • Bei einer hybriden „Acquire-Release“-Reihenfolge wird stattdessen eine „Acquire“-Operation ausgeführt.


Andernfalls ist die Standard-Speicherreihenfolge die sequenzielle konsistente Reihenfolge.

Hinweis: Sie sollten die Vorlagenargumente niemals explizit benennen, sondern ausschließlich die Ableitung von Klassenvorlagenargumenten (CTAD) verwenden und den Compiler das Vorlagenargument auswählen lassen.

Hinweis: Es besteht die Möglichkeit, dass auch andere Threads die Variable ändern, was bedeutet, dass Aktualisierungen, die von anderen Threads zwischen dem Aufruf des Konstruktors von `QAtomicScopedValueRollback` und ` commit()` oder zwischen ` commit()` und dem Destruktor vorgenommen wurden, möglicherweise verloren gehen.

Siehe auch ` QScopedValueRollback`.

Dokumentation zu den Mitgliedsfunktionen

[explicit constexpr] QAtomicScopedValueRollback::QAtomicScopedValueRollback(QBasicAtomicInteger<T> &var, std::memory_order mo = std::memory_order_seq_cst)

[explicit constexpr] QAtomicScopedValueRollback::QAtomicScopedValueRollback(QBasicAtomicPointer<std::remove_pointer_t<T>> &var, std::memory_order mo = std::memory_order_seq_cst)

[explicit constexpr] QAtomicScopedValueRollback::QAtomicScopedValueRollback(std::atomic<T> &var, std::memory_order mo = std::memory_order_seq_cst)

Speichert den Wert von „ var “, um ihn bei der Zerstörung wiederherzustellen.

Dies entspricht:

T old_value = var.load(mo);
// And in the destructor: var.store(old_value, mo);

Die Anpassung von „ mo “ für den Ladevorgang wird im Abschnitt „ Memory Order “ beschrieben.

[explicit constexpr] QAtomicScopedValueRollback::QAtomicScopedValueRollback(QBasicAtomicInteger<T> &var, T value, std::memory_order mo = std::memory_order_seq_cst)

[explicit constexpr] QAtomicScopedValueRollback::QAtomicScopedValueRollback(QBasicAtomicPointer<std::remove_pointer_t<T>> &var, T value, std::memory_order mo = std::memory_order_seq_cst)

[explicit constexpr] QAtomicScopedValueRollback::QAtomicScopedValueRollback(std::atomic<T> &var, T value, std::memory_order mo = std::memory_order_seq_cst)

Weist „ value “ dem Wert „ var “ zu und speichert den vorherigen Wert von „ var “ intern, um ihn bei der Zerstörung wiederherzustellen.

Dies entspricht folgendem Code:

T old_value = var.exchange(new_value, mo);
// And in the destructor: var.store(old_value, mo);

QAtomicScopedValueRollback::~QAtomicScopedValueRollback()

Setzt die verwaltete Variable auf den Wert zurück, der zum Zeitpunkt der Erstellung oder beim letzten Aufruf von ` commit()` gespeichert war.

Dies entspricht:

// In the constructor: T old_value = var.load(mo);
// or: T old_value = exchange(new_value, mo);
var.store(old_value, mo);

Dabei entspricht ` mo ` dem Wert, der ursprünglich an den Konstruktor übergeben wurde. Die Bedeutung von ` mo` finden Sie unter Memory Order.

void QAtomicScopedValueRollback::commit()

Aktualisiert den gespeicherten Wert auf den aktuellen Wert der verwalteten Variablen, wobei die Speicherreihenfolge derjenigen bei der Erstellung entspricht.

Dieser aktualisierte Wert wird bei der Zerstörung anstelle des ursprünglichen vorherigen Werts wiederhergestellt.

Dies entspricht:

// Given constructor: T old_value = var.load(mo);
old_value = var.load(mo);  // referesh it
// And, in the destructor: var.store(old_value, mo);

Wobei ` mo ` mit dem Wert übereinstimmt, der ursprünglich an den Konstruktor übergeben wurde. Die Bedeutung von ` mo` finden Sie unter Memory Order.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.