QAtomicScopedValueRollback Class
template <typename T> class QAtomicScopedValueRollbackFournit une « QScopedValueRollback » pour les variables atomiques. En savoir 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
QAtomicScopedValueRollback<T> réinitialise une variable atomique de type T à sa valeur précédente lors de sa destruction. Elle peut être utilisée pour rétablir l'état initial lorsqu'une exception est levée, sans qu'il soit nécessaire d'écrire des blocs try-catch.
Elle peut également servir à gérer des variables définies temporairement, telles que les conditions de réentrance. Grâce à cette classe, la variable sera réinitialisée, que la fonction se termine normalement, qu'elle soit interrompue prématurément par une instruction return ou qu'elle se termine 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 à l’aide de la valeur de mo. L’ordre de mémoire suit le mappage suivant :
- Lors de l'écriture dans la variable atomique :
- Un ordre « acquire » effectue à la place une opération « relaxed ».
- Un ordre hybride « acquire-release » effectue à la place une opération de libération.
- Lors de la lecture de la variable atomique :
- Un ordre « release » effectue à la place une opération « relaxed ».
- Un ordre « consume » effectue une opération de consommation.
- Un ordre hybride « acquire-release » effectue à la place une opération d’acquisition.
Sinon, l’ordre de mémoire par défaut est l’ordre séquentiellement cohérent.
Remarque : vous ne devez jamais nommer explicitement les arguments de modèle, mais utiliser exclusivement la déduction des arguments de modèle de classe (CTAD) et laisser le compilateur choisir l’argument de modèle.
Voir également ` QScopedValueRollback`.
Documentation des fonctions membres
[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)
Enregistre la valeur de ` var ` afin de la restaurer lors de la destruction.
Cela équivaut à :
T old_value = var.load(mo);
// And in the destructor: var.store(old_value, mo);L'ajustement de l'mo e pour la charge est décrit dans la section « Memory Order ».
[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)
Attribue la valeur « value » à « var » et stocke en interne la valeur précédente de « var » afin de la rétablir lors de la destruction de l'objet.
Cela équivaut à :
T old_value = var.exchange(new_value, mo);
// And in the destructor: var.store(old_value, mo);QAtomicScopedValueRollback::~QAtomicScopedValueRollback()
Restaure dans la variable gérée la valeur enregistrée qui était active au moment de la construction ou lors du dernier appel à la fonction ` commit()`.
Cela revient à :
// 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 identique à celui initialement passé au constructeur. Voir Memory Order pour la signification de ` mo`.
void QAtomicScopedValueRollback::commit()
Met à jour la valeur stockée en lui attribuant la valeur actuelle de la variable gérée, chargée selon le même ordre de mémoire qu’au moment de sa construction.
Cette valeur mise à jour sera restaurée lors de la destruction, à la place de la valeur initiale.
Cela équivaut à :
// 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 identique à celui initialement transmis 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.
