Biblioteca atómica C ++: comparar Exchange

Descripción

Compara atómicamente el valor del objeto atómico con el argumento no atómico y realiza intercambio atómico si es igual o carga atómica si no.

Declaración

A continuación se muestra la declaración de std :: atomic_compare_exchange_weak.

template< class T >
bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, 
                                   T* expected, T desired );

C ++ 11

template< class T <
bool atomic_compare_exchange_weak( std::atomic<T>* obj, 
                                   T* expected, T desired );

A continuación se muestra la declaración para std :: atomic_compare_exchange_strong.

template< class T >
bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj,
                                     T* expected, T desired );

C ++ 11

template< class T >
bool atomic_compare_exchange_strong( std::atomic<T>* obj,
                                     T* expected, T desired );

A continuación se muestra la declaración para std :: atomic_compare_exchange_weak_explicit.

template< class T >
bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj,
                                            T* expected, T desired,
                                            std::memory_order succ, 
                                            std::memory_order fail );

C ++ 11

template< class T >
bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj,
                                            T* expected, T desired,
                                            std::memory_order succ, 
                                            std::memory_order fail );

A continuación se muestra la declaración de std :: atomic_compare_exchange_strong_explicit.

template< class T >
bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj,
                                              T* expected, T desired,
                                              std::memory_order succ, 
                                              std::memory_order fail );

C ++ 11

template< class T >
bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj, 
                                              T* expected, T desired,
                                              std::memory_order succ, 
                                              std::memory_order fail );

Parámetros

obj - Se utiliza como puntero al objeto atómico a modificar.
desr - Se utiliza para almacenar el valor en el objeto atómico.
order - Se utiliza para sincronizar el orden de la memoria para esta operación.
succ- Se utiliza en 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.
fail- Se utiliza en la ordenación de sincronización de memoria para la operación de carga si falla la comparación. No puede ser std :: memory_order_release o std :: memory_order_acq_rel y no puede especificar un orden más fuerte que succ.

Valor devuelto

Devuelve el resultado de la comparación: verdadero si * obj era igual a * esperado, falso en caso contrario.

Excepciones

No-noexcept - esta función miembro nunca arroja excepciones.

Ejemplo

En el siguiente ejemplo para std :: atomic_compare_exchange.

#include <atomic>

template<class T>
struct node {
   T data;
   node* next;
   node(const T& data) : data(data), next(nullptr) {}
};

template<class T>
class stack {
   std::atomic<node<T>*> head;
   public:
      void push(const T& data) {
         node<T>* new_node = new node<T>(data);
         new_node->next = head.load(std::memory_order_relaxed);
         while(!std::atomic_compare_exchange_weak_explicit(&head, &new_node->next,
            new_node, std::memory_order_release, std::memory_order_relaxed))
            ;
      }
};

int main() {
   stack<int> s;
   s.push(1);
   s.push(2);
   s.push(3);
}

↰ Previous page