Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

QAtomicScopedValueRollback Class

template <typename T> class QAtomicScopedValueRollback

Fournit une adresse QScopedValueRollback pour les variables atomiques. Plus...

En-tête : #include <QAtomicScopedValueRollback>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Depuis : Qt 6.7

Fonctions publiques

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()

Description détaillée

La classe QAtomicScopedValueRollback réinitialise une variable atomique à sa valeur antérieure lors de sa destruction. Elle peut être utilisée pour revenir à l'état initial lorsqu'une exception est levée sans qu'il soit nécessaire d'écrire des blocs try-catch.

Elle peut également être utilisée pour gérer les variables qui sont temporairement définies, comme les gardes de réentrance. En utilisant cette classe, la variable sera réinitialisée que la fonction soit quittée normalement, qu'elle soit quittée prématurément par une instruction de retour ou qu'elle soit quittée par une exception.

La classe fonctionne avec std::atomic et les classes atomiques de Qt : QBasicAtomicInteger, QAtomicInteger, QAtomicInt, QBasicAtomicPointer et QAtomicPointer.

Les accès mémoire à la variable atomique var sont spécifiés en utilisant la valeur de mo. L'ordre mémoire suit cette correspondance :

  • Lors de l'écriture dans la variable atomique :
    • Une commande d'acquisition effectue une opération de relâchement à la place.
    • Une commande hybride d'acquisition et de libération effectue une opération de libération à la place.
  • Lors de la lecture de la variable atomique :
    • Une commande release effectue une opération relaxée à la place.
    • Une commande "consume" effectue une opération "consume".
    • Une commande hybride d'acquisition et de libération effectue une opération d'acquisition à la place.


Sinon, l'ordre de mémoire par défaut est l'ordre séquentiel cohérent.

Remarque : vous ne devez jamais nommer explicitement les arguments du modèle, mais utiliser exclusivement la déduction d'arguments de modèle de classe (CTAD) et laisser le compilateur choisir l'argument du modèle.

Remarque : il est possible que d'autres threads modifient également la variable, ce qui signifie que vous pouvez perdre les mises à jour effectuées par d'autres threads entre l'appel au constructeur QAtomicScopedValueRollback et commit() ou entre commit() et le destructeur.

Voir également QScopedValueRollback.

Documentation des fonctions membres

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

[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)

Enregistre la valeur de var afin de la restaurer en cas de destruction.

Cela équivaut à :

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

L'ajustement de la charge à mo est décrit dans la section Memory Order.

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

[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)

Attribue value à var et stocke la valeur antérieure de var en interne pour la rétablir en cas de destruction.

Cela équivaut à :

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

QAtomicScopedValueRollback::~QAtomicScopedValueRollback()

Restaure la valeur stockée qui était courante au moment de la construction, ou lors du dernier appel à commit(), dans la variable gérée.

Cela équivaut à :

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

Où mo est le même que celui passé initialement au constructeur. Voir Memory Order pour la signification de mo.

void QAtomicScopedValueRollback::commit()

Met à jour la valeur stockée avec la valeur actuelle de la variable gérée, chargée avec le même ordre de mémoire que lors de la construction.

Cette valeur mise à jour sera restaurée lors de la destruction, à la place de la valeur initiale.

Ceci est équivalent à :

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

Où mo est le même que celui passé initialement au constructeur. Voir Memory Order pour la signification de mo.

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