std::experimental::atomic_shared_ptr<T>:: compare_exchange_strong, std::experimental::atomic_shared_ptr<T>:: compare_exchange_weak

bool compare_exchange_weak ( std:: shared_ptr < T > & expected, const std:: shared_ptr < T > & desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(1)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > && desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(2)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, const std:: shared_ptr < T > & desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(3)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > && desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(4)
bool compare_exchange_strong ( std:: shared_ptr < T > & expected, const std:: shared_ptr < T > & desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(5)
bool compare_exchange_strong ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > && desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(6)
bool compare_exchange_strong ( std:: shared_ptr < T > & expected, const std:: shared_ptr < T > & desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(7)
bool compare_exchange_strong ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > && desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(8)

Compara atómicamente el subyacente shared_ptr en * this con expected , y si son equivalentes, reemplaza el primero con desired (realiza una operación de lectura-modificación-escritura). De lo contrario, carga el valor real almacenado en * this en expected (realiza una operación de carga). El reemplazo se realiza como si fuera mediante el operador de asignación de copia o movimiento de shared_ptr , según corresponda.

Dos shared_ptr son equivalentes si y solo si almacenan el mismo valor de puntero y comparten la propiedad.

Los modelos de memoria para las operaciones de lectura-modificación-escritura y carga son success y failure respectivamente. Para las sobrecargas (3,4,7,8) , order se utiliza tanto para las operaciones de lectura-modificación-escritura como para las de carga, excepto que std::memory_order_acquire y std::memory_order_relaxed se utilizan para la operación de carga si order == std:: memory_order_acq_rel , o order == std:: memory_order_release respectivamente.

Las versiones débiles (1-4) pueden fallar esporádicamente.

Contenidos 1 Parámetros 2 Valor de retorno 3 Observaciones 4 Notas 5 Véase también

Parámetros

expected	-	referencia al valor que se espera encontrar en el objeto atómico
desired	-	el valor a almacenar en el objeto atómico si es igual al esperado
success	-	el orden de sincronización de memoria para la operación de lectura-modificación-escritura si la comparación tiene éxito. Se permiten todos los valores
failure	-	el orden de sincronización de memoria para la operación de carga si la comparación falla. No puede ser std::memory_order_release o std::memory_order_acq_rel y no puede especificar un ordenamiento más fuerte que success
order	-	el orden de sincronización de memoria para ambas operaciones

Valor de retorno

true si el valor atómico subyacente fue modificado, false en caso contrario.

Observaciones

Todos los cambios al objeto atomic_shared_ptr mismo, y todos los incrementos asociados del use_count , están garantizados de realizarse atómicamente. Los decrementos asociados del use_count ocurren después de la operación atómica, pero no se requiere que sean parte de ella. Cualquier operación asociada de destrucción o desasignación ocurre después de la operación atómica y no forma parte de ella.

Si la operación de comparación-intercambio devuelve true , expected no se accede después del paso de actualización atómica. Si devuelve false , expected se actualiza con el valor existente leído del objeto atomic_shared_ptr en el intento de actualización atómica. La actualización de use_count correspondiente a la escritura en expected es parte de la operación atómica, pero la escritura en expected misma no está requerida para ser parte de la operación atómica.

Para las sobrecargas (1,3,5,7) , desired no se accede después del paso de actualización atómica.

Para las sobrecargas (2,4,6,8) , desired se mueve desde solo si la operación de comparación-intercambio devuelve true ; el movimiento ocurre después del paso de actualización atómica.

Notas

Las formas débiles (1-4) de las funciones pueden fallar espuriamente, es decir, actuar como si * this y expected no fueran equivalentes incluso cuando lo son. Cuando un compare-and-exchange está en un bucle, la versión débil proporcionará mejor rendimiento en algunas plataformas.

Véase también

std::atomic_is_lock_free (std::shared_ptr) std::atomic_load (std::shared_ptr) std::atomic_load_explicit (std::shared_ptr) std::atomic_store (std::shared_ptr) std::atomic_store_explicit (std::shared_ptr) std::atomic_exchange (std::shared_ptr) std::atomic_exchange_explicit (std::shared_ptr) std::atomic_compare_exchange_weak (std::shared_ptr) std::atomic_compare_exchange_strong (std::shared_ptr) std::atomic_compare_exchange_weak_explicit (std::shared_ptr) std::atomic_compare_exchange_strong_explicit (std::shared_ptr) (obsoleto en C++20) (eliminado en C++26)

especializa operaciones atómicas para std::shared_ptr (plantilla de función)