QAtomicScopedValueRollback Class
template <typename T> class QAtomicScopedValueRollbackProporciona un « QScopedValueRollback » para las variables atómicas. Más información...
| Encabezado: | #include <QAtomicScopedValueRollback> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Desde: | Qt 6.7 |
Funciones públicas
| 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() |
Descripción detallada
QAtomicScopedValueRollback<T> restablece una variable atómica de tipo T a su valor anterior al ser destruida. Se puede utilizar para revertir el estado cuando se lanza una excepción sin necesidad de escribir bloques try-catch.
También se puede utilizar para gestionar variables que se establecen de forma temporal, como los controles de reentrada. Al utilizar esta clase, la variable se restablecerá independientemente de si la función finaliza normalmente, se sale de ella anticipadamente mediante una instrucción «return» o se sale de ella debido a una excepción.
La clase funciona con std::atomic y con las clases atómicas de Qt: QBasicAtomicInteger, QAtomicInteger, QAtomicInt, QBasicAtomicPointer y QAtomicPointer.
Los accesos a la memoria de la variable atómica var se especifican utilizando el valor de mo. El orden de la memoria sigue esta correspondencia:
- Al escribir en la variable atómica:
- Un orden de adquisición realiza, en su lugar, una operación relajada.
- Un orden híbrido de adquisición-liberación realiza, en su lugar, una operación de liberación.
- Al leer de la variable atómica:
- Un orden de «release» realiza, en su lugar, una operación relajada.
- Un orden de consumo realiza una operación de consumo.
- Un orden híbrido de adquisición-liberación realiza, en su lugar, una operación de adquisición.
De lo contrario, el orden de memoria predeterminado es el orden secuencial consistente.
Nota: Nuncadebes nombrar los argumentos de la plantilla de forma explícita, sino utilizar exclusivamente la deducción de argumentos de plantillas de clase (CTAD) y dejar que el compilador elija el argumento de la plantilla.
Véase también ` QScopedValueRollback`.
Documentación de las funciones miembro
[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)
Guarda el valor de « var » para restaurarlo en el momento de su destrucción.
Esto equivale a:
T old_value = var.load(mo);
// And in the destructor: var.store(old_value, mo);El ajuste de « mo » para la carga se describe en la sección « 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)
Asigna « value » a « var » y almacena internamente el valor anterior de « var » para revertirlo al destruirse el objeto.
Esto equivale a:
T old_value = var.exchange(new_value, mo);
// And in the destructor: var.store(old_value, mo);QAtomicScopedValueRollback::~QAtomicScopedValueRollback()
Restablece en la variable gestionada el valor almacenado que estaba vigente en el momento de la construcción o en la última llamada a ` commit()`.
Esto equivale a:
// In the constructor: T old_value = var.load(mo);
// or: T old_value = exchange(new_value, mo);
var.store(old_value, mo);Donde ` mo ` es el mismo que el pasado inicialmente al constructor. Consulte Memory Order para conocer el significado de ` mo`.
void QAtomicScopedValueRollback::commit()
Actualiza el valor almacenado con el valor actual de la variable gestionada, cargado con el mismo orden de memoria que en el momento de su creación.
Este valor actualizado se restaurará en el momento de la destrucción, en lugar del valor original anterior.
Esto equivale a:
// Given constructor: T old_value = var.load(mo);
old_value = var.load(mo); // referesh it
// And, in the destructor: var.store(old_value, mo);Donde ` mo ` es el mismo que el pasado inicialmente al constructor. Consulta Memory Order para conocer el significado 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.