<atomic> Header File Summary 1std::atomic_flag Class Summary
namespace STD {typedef struct ATOMIC_FLAG {bool Test_and_set (Memory_order = memory_order_seq_cst) volatile;
BOOL Test_and_set (memory_order = MEMORY_ORDER_SEQ_CST);
void Clear (Memory_order = memory_order_seq_cst) volatile;
void Clear (Memory_order = MEMORY_ORDER_SEQ_CST);
Atomic_flag () = default;
Atomic_flag (const atomic_flag&) = delete;
atomic_flag& operator= (const atomic_flag&) = delete;
atomic_flag& operator= (const atomic_flag&) volatile = delete;
} Atomic_flag;
BOOL Atomic_flag_test_and_set (volatile atomic_flag*);
BOOL Atomic_flag_test_and_set (atomic_flag*);
BOOL Atomic_flag_test_and_set_explicit (volatile atomic_flag*, memory_order);
BOOL Atomic_flag_test_and_set_explicit (atomic_flag*, Memory_order);
void Atomic_flag_clear (volatile atomic_flag*);
void Atomic_flag_clear (atomic_flag*);
void atomic_flag_clear_explicit (volatile atomic_flag*, memory_order);void Atomic_flag_clear_explicit (atomic_flag*, Memory_order);
#define ATOMIC_FLAG_INIT below} 2 std::atomic Basic Type Summary
Template <class t> struct Atomic {bool Is_lock_free () const volatile;
BOOL Is_lock_free () const;
void Store (T, memory_order = memory_order_seq_cst) volatile;
void Store (T, memory_order = MEMORY_ORDER_SEQ_CST);
T Load (memory_order = MEMORY_ORDER_SEQ_CST) const volatile;
T Load (memory_order = MEMORY_ORDER_SEQ_CST) const;
operator T () const volatile;
operator T () const;
T Exchange (t, Memory_order = MEMORY_ORDER_SEQ_CST) volatile;
T Exchange (t, Memory_order = MEMORY_ORDER_SEQ_CST);
BOOL Compare_exchange_weak (t&, T, Memory_order, memory_order) volatile;
BOOL Compare_exchange_weak (t&, T, Memory_order, Memory_order);
BOOL Compare_exchange_strong (t&, T, Memory_order, memory_order) volatile;
BOOL Compare_exchange_strong (t&, T, Memory_order, Memory_order);
BOOL Compare_exchange_weak (t&, T, Memory_order = memory_order_seq_cst) volatile; BOOL Compare_exchange_weak (t&, T, Memory_order = Memory_ordeR_SEQ_CST);
BOOL Compare_exchange_strong (t&, T, Memory_order = memory_order_seq_cst) volatile;
BOOL Compare_exchange_strong (t&, T, memory_order = MEMORY_ORDER_SEQ_CST);
Atomic () = default;
constexpr Atomic (T);
Atomic (const atomic&) = delete;
atomic& operator= (const atomic&) = delete;
atomic& operator= (const atomic&) volatile = delete;
T operator= (t) volatile;
T operator= (t);
}; 3 std::atomic integer-specific summary
Template <> struct Atomic<integral> {bool Is_lock_free () const volatile;
BOOL Is_lock_free () const;
void store (integral, Memory_order = MEMORY_ORDER_SEQ_CST) volatile;
void store (integral, memory_order = MEMORY_ORDER_SEQ_CST);
Integral load (Memory_order = MEMORY_ORDER_SEQ_CST) const volatile;
Integral load (Memory_order = MEMORY_ORDER_SEQ_CST) const;
operator integral () const volatile;
operator integral () const;
Integral Exchange (integral, Memory_order = MEMORY_ORDER_SEQ_CST) volatile;
Integral Exchange (integral, memory_order = MEMORY_ORDER_SEQ_CST);
BOOL Compare_exchange_weak (integral&, Integral, Memory_order, memory_order) volatile;
BOOL Compare_exchange_weak (integral&, Integral, Memory_order, memory_order);
BOOL Compare_exchange_strong (integral&, Integral, Memory_order, memory_order) volatile;
BOOL Compare_exchange_strong (integral&, Integral, Memory_order, memory_order); BOOL Compare_exchaNge_weak (integral&, integral, Memory_order = MEMORY_ORDER_SEQ_CST) volatile;
BOOL Compare_exchange_weak (integral&, integral, memory_order = MEMORY_ORDER_SEQ_CST);
BOOL Compare_exchange_strong (integral&, integral, Memory_order = MEMORY_ORDER_SEQ_CST) volatile;
BOOL Compare_exchange_strong (integral&, integral, memory_order = MEMORY_ORDER_SEQ_CST);
Integral Fetch_add (integral, memory_order = MEMORY_ORDER_SEQ_CST) volatile;
Integral Fetch_add (integral, memory_order = MEMORY_ORDER_SEQ_CST);
Integral fetch_sub (integral, memory_order = MEMORY_ORDER_SEQ_CST) volatile;
Integral fetch_sub (integral, memory_order = MEMORY_ORDER_SEQ_CST);
Integral Fetch_and (integral, memory_order = MEMORY_ORDER_SEQ_CST) volatile;
Integral Fetch_and (integral, memory_order = MEMORY_ORDER_SEQ_CST);
Integral Fetch_or (integral, memory_order = MEMORY_ORDER_SEQ_CST) volatile;
Integral Fetch_or (integral, memory_order = MEMORY_ORDER_SEQ_CST); Integral fetch_xor (integral, memory_order = MEMORY_ORDER_SEQ_CST) volatile;
Integral Fetch_xor (integral, memory_order = MEMORY_ORDER_SEQ_CST);
Atomic () = default;
constexpr Atomic (integral);
Atomic (const atomic&) = delete;
atomic& operator= (const atomic&) = delete;
atomic& operator= (const atomic&) volatile = delete;
Integral operator= (integral) volatile;
Integral operator= (integral);
Integral operator++ (int) volatile;
Integral operator++ (int);
Integral operator--(int) volatile;
Integral operator--(int);
Integral operator++ () volatile;
Integral operator++ ();
Integral operator--() volatile;
Integral operator--();
Integral operator+= (integral) volatile;
Integral operator+= (integral);
Integral operator-= (integral) volatile;
Integral operator-= (integral);
Integral operator&= (integral) volatile;
Integral operator&= (integral);
Integral operator|= (integral) volatile; Integral operator|= (integral);
Integral operator^= (integral) volatile;
Integral operator^= (integral);
}; 4 std::atomic Pointer Special summary
Template <class t> struct atomic<t*> {bool Is_lock_free () const volatile;
BOOL Is_lock_free () const;
void Store (t*, memory_order = memory_order_seq_cst) volatile;
void Store (t*, memory_order = MEMORY_ORDER_SEQ_CST);
t* Load (memory_order = MEMORY_ORDER_SEQ_CST) const volatile;
t* Load (memory_order = MEMORY_ORDER_SEQ_CST) const;
operator t* () const volatile;
operator t* () const;
t* Exchange (t*, Memory_order = memory_order_seq_cst) volatile;
t* Exchange (t*, memory_order = MEMORY_ORDER_SEQ_CST);
BOOL Compare_exchange_weak (t*&, t*, Memory_order, memory_order) volatile;
BOOL Compare_exchange_weak (t*&, t*, Memory_order, Memory_order);
BOOL Compare_exchange_strong (t*&, t*, Memory_order, memory_order) volatile;
BOOL Compare_exchange_strong (t*&, t*, Memory_order, Memory_order);
BOOL Compare_exchange_weak (t*&, t*, Memory_order = memory_order_seq_cst) volatile; BOOL Compare_exchange_weak (t*&, t*, memory_order = MEMORY_ORDER_SEQ_CST);
BOOL Compare_exchange_strong (t*&, t*, Memory_order = memory_order_seq_cst) volatile;
BOOL Compare_exchange_strong (t*&, t*, memory_order = MEMORY_ORDER_SEQ_CST);
t* Fetch_add (ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
t* Fetch_add (ptrdiff_t, memory_order = MEMORY_ORDER_SEQ_CST);
t* fetch_sub (ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
t* fetch_sub (ptrdiff_t, memory_order = MEMORY_ORDER_SEQ_CST);
Atomic () = default;
constexpr Atomic (t*);
Atomic (const atomic&) = delete;
atomic& operator= (const atomic&) = delete;
atomic& operator= (const atomic&) volatile = delete;
t* operator= (t*) volatile;
t* operator= (t*);
t* operator++ (int) volatile;
t* operator++ (int);
t* operator--(int) volatile;
t* operator--(int);
t* operator++ () volatile;
t* operator++ ();
t* operator--() volatile;
t* operator--(); t* operator+ + (ptrdiff_t) volatile;
t* operator+= (ptrdiff_t);
t* operator-= (ptrdiff_t) volatile;
t* operator-= (ptrdiff_t); };
The following is a summary of the class for boost's atomic library:
Template<typename t>
class Atomic:public Atomics::d etail::base_atomic<t>
{public
:
Atomic () = default;//default construct
explicit atomic (T v);//Specify initial value construct
atomic (atomic const&) = delete;//prohibit copying
between objects atomic& operator=atomic (atomic const&) = delete;//prohibit assignment between objects
bool Is_lock_free ();/whether there is no lock
void Store (T Value)//Deposit value
t load ();//value
t operator= (t v) volatile;//assignment
operator T () volatile const;//implicit type conversion, equivalent to load
T Exchange (t new_value);//deposit value, returning the original value
bool Compare_exchange_weak (t &expected,t desired);
bool Compare_exchange_strong (t &expected, t desired);/
T & Storage ()//Get internal value
T const& storage () const;//
};
Usage:
#include <cassert> #include <iostream> #include <string> #include <vector> #include <set>
#include <map> #include <algorithm> using namespace std;
#include <boost/atomic.hpp> using namespace boost;
void Case1 () {atomic<int> A (10);
assert (A = = 10);
Atomic<long> l;
L = 100L;
cout << l << Endl;
Atomic<double> d (2.414);
cout << D << Endl;
}//////////////////////////////////////////void Case2 () {atomic<bool> b{false};
ASSERT (!b.load ());
B.store (TRUE);
ASSERT (b);
atomic<int> N (100);
ASSERT (N.exchange (200) = = 100);
ASSERT (n = = 200);
}//////////////////////////////////////////void Case3 () {atomic<long> L (100);
Long v = 100;
if (L.compare_exchange_weak (V, 313)) {assert (L = = 313 && v = 100);
} v = 200;
Auto B = L.compare_exchange_strong (V, 99);
ASSERT (!b && v = 313); L.compare_exchange_weak (v, 99);
ASSERT (L = = && v = 313); }//////////////////////////////////////////#include <boost/utility.hpp> void Case4 () {atomic<int> N (100
);
ASSERT (N.fetch_add (10) = = 100);
ASSERT (n = = 110);
ASSERT (++n = 111);
ASSERT (n++ = 111);
ASSERT (n = = 112);
ASSERT ((N-= 10) = = 102);
Atomic<int> b{boost_binary (1101)};
Auto x = B.fetch_and (Boost_binary (0110));
ASSERT (x = = Boost_binary (1101) && b = = Boost_binary (0100));
ASSERT ((b |= boost_binary (1001)) = = Boost_binary (1101));
}//////////////////////////////////////////void Case5 () {atomic<bool> b{true};
ASSERT (b);
b = false;
ASSERT (!b.load ());
Auto x = B.exchange (true);
ASSERT (b &&!x);
int main () {case1 ();
Case2 ();
CASE3 ();
Case4 ();
CASE5 (); }
Run Result:
2.414