Back to Qt.io
Contact Us Blog Download Qt

QAtomicScopedValueRollback Class

template <typename T> class QAtomicScopedValueRollback

Bietet eine QScopedValueRollback für atomare Variablen. Mehr...

Kopfzeile: #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()

Detaillierte Beschreibung

Die Klasse QAtomicScopedValueRollback setzt eine atomare Variable bei ihrer Zerstörung auf ihren vorherigen Wert zurück. Sie kann verwendet werden, um den Zustand wiederherzustellen, wenn eine Ausnahme ausgelöst wird, ohne dass Try-Catch-Blöcke geschrieben werden müssen.

Sie kann auch verwendet werden, um Variablen zu verwalten, die vorübergehend gesetzt sind, wie z. B. Reentrancy Guards. Bei Verwendung dieser Klasse wird die Variable zurückgesetzt, unabhängig davon, ob die Funktion normal, vorzeitig durch eine Return-Anweisung 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 spezifiziert. Die Speicherreihenfolge folgt dieser Zuordnung:

  • Beim Schreiben in die atomare Variable:
    • Eine Erfassungsreihenfolge führt stattdessen eine Freigabeoperation durch.
    • Eine hybride acquire-release-Reihenfolge führt stattdessen eine release-Operation durch.
  • Beim Lesen aus der atomaren Variable:
    • Eine Release-Bestellung führt stattdessen eine entspannte Operation aus.
    • Eine consume-Bestellung führt eine consume-Operation durch.
    • Eine hybride acquire-release-Bestellung führt stattdessen eine acquire-Operation durch.


Andernfalls ist die Standard-Speicherreihenfolge die sequentielle konsistente Reihenfolge.

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

Hinweis: Es besteht die Möglichkeit, dass andere Threads die Variable ebenfalls ändern, was bedeutet, dass Aktualisierungen, die von anderen Threads zwischen dem Aufruf des QAtomicScopedValueRollback-Konstruktors und commit() oder zwischen commit() und dem Destruktor durchgeführt werden, verloren gehen können.

Siehe auch QScopedValueRollback.

Dokumentation der 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)

Zeichnet den Wert von var auf, um ihn bei Zerstörung wiederherzustellen.

Dies ist gleichbedeutend mit:

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

Die Anpassung von mo an die Last 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 var zu und speichert intern den vorherigen Wert von var, um ihn bei Zerstörung wiederherzustellen.

Dies ist äquivalent zu:

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

QAtomicScopedValueRollback::~QAtomicScopedValueRollback()

Stellt den gespeicherten Wert, der zum Zeitpunkt der Erstellung oder des letzten Aufrufs von commit() aktuell war, in der verwalteten Variablen wieder her.

Dies ist äquivalent zu:

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

Dabei ist mo derselbe Wert wie der, der ursprünglich an den Konstruktor übergeben wurde. Siehe Memory Order für die Bedeutung von mo.

void QAtomicScopedValueRollback::commit()

Aktualisiert den gespeicherten Wert auf den aktuellen Wert der verwalteten Variablen, der in der gleichen Speicherreihenfolge wie bei der Erstellung geladen wird.

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

Dies ist äquivalent zu:

// 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 derselbe ist wie der ursprünglich an den Konstruktor übergebene Wert. Siehe Memory Order für die Bedeutung von mo.

© 2025 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.