Back to Qt.io
Contact Us Blog Download Qt
En esta página

QAtomicScopedValueRollback Class

template <typename T> class QAtomicScopedValueRollback

Proporciona un QScopedValueRollback para variables atómicas. Más...

Cabecera: #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

La clase QAtomicScopedValueRollback restablece una variable atómica a su valor anterior al ser destruida. Puede utilizarse 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 temporalmente, como guardias de reentrada. Utilizando esta clase, la variable se restablecerá tanto si la función se abandona normalmente, como si se abandona antes de tiempo mediante una sentencia return, o si se abandona mediante una excepción.

La clase funciona con std::atomic y las clases atómicas de Qt: QBasicAtomicInteger, QAtomicInteger, QAtomicInt, QBasicAtomicPointer y QAtomicPointer.

Los accesos de memoria a la variable atómica var se especifican utilizando el valor de mo. El orden de memoria sigue este mapeo:

  • Al escribir en la variable atómica:
    • Una ordenación de adquisición realiza una operación de relajación en su lugar.
    • Una ordenación híbrida adquirir-liberar realiza una operación de liberación.
  • Al leer de la variable atómica:
    • Una ordenación de liberación realiza una operación relajada.
    • Una ordenación consumir realiza una operación consumir.
    • Una ordenación híbrida adquirir-liberar realiza en su lugar una operación adquirir.


De lo contrario, el orden de memoria por defecto es el orden secuencial consistente.

Nota: Nunca debe nombrar los argumentos de plantilla explícitamente, sino utilizar exclusivamente la Deducción de Argumentos de Plantilla de Clase (CTAD) y dejar que el compilador elija el argumento de plantilla.

Nota: Existe la posibilidad de que otros hilos también modifiquen la variable, lo que significa que puedes perder las actualizaciones realizadas por otros hilos entre la llamada al constructor QAtomicScopedValueRollback y commit() o entre commit() y el destructor.

Ver también QScopedValueRollback.

Documentación de las funciones miembro

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

Registra el valor de var para restablecerlo en caso de destrucción.

Esto equivale a:

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

El ajuste mo para la carga se describe en la sección 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)

Asigna value a var y almacena internamente el valor anterior de var para revertirlo en caso de destrucción.

Esto es equivalente a:

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

QAtomicScopedValueRollback::~QAtomicScopedValueRollback()

Restaura el valor almacenado que era actual en el momento de la construcción, o en la última llamada a commit(), a la variable gestionada.

Esto es equivalente 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 se pasó inicialmente al constructor. Véase Memory Order para el significado de mo.

void QAtomicScopedValueRollback::commit()

Actualiza el valor almacenado al valor actual de la variable gestionada, cargado con el mismo orden de memoria que en la construcción.

Este valor actualizado se restaurará en el momento de la destrucción, en lugar del valor original anterior.

Esto es equivalente 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 se pasó inicialmente al constructor. Véase Memory Order para 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.