Bibliothèque atomique C ++ - Comparez Exchange

La description

Il compare atomiquement la valeur de l'objet atomique avec un argument non atomique et effectue un échange atomique s'il est égal ou une charge atomique sinon.

Déclaration

Voici la déclaration pour 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 );

Voici la déclaration pour 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 );

Voici la déclaration pour 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 );

Voici la déclaration pour 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 );

Paramètres

• obj - Il est utilisé en pointeur sur l'objet atomique à modifier.

• desr - Il est utilisé pour stocker la valeur dans l'objet atomique.

• order - Il est utilisé pour synchroniser l'ordre de la mémoire pour cette opération.

• succ- Il est utilisé dans l'ordre de synchronisation de la mémoire pour l'opération de lecture-modification-écriture si la comparaison réussit. Toutes les valeurs sont autorisées.

• fail- Il est utilisé dans l'ordre de synchronisation de la mémoire pour l'opération de chargement si la comparaison échoue. Ne peut pas être std :: memory_order_release ou std :: memory_order_acq_rel et ne peut pas spécifier un ordre plus fort que succ.

Valeur de retour

Il renvoie le résultat de la comparaison: vrai si * obj était égal à * attendu, faux sinon.

Des exceptions

No-noexcept - cette fonction membre ne lève jamais d'exceptions.

Exemple

Dans l'exemple ci-dessous pour 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);
}