前面三篇文章《C++11 并發指南六(atomic 類型詳解一 atomic_flag 介紹)》、《C++11 并發指南六( <atomic> 類型詳解二 std::atomic )》、《C++11 并發指南六(atomic 類型詳解三 std::atomic (續))》都是采用 C++ 的方式介紹原子對象，本節我會給大家介紹 C++11 原子操作中 C 風格的 API。
總地來說，C++11 標準中規定了兩大類原子對象，std::atomic_flag 和 std::atomic，前者 std::atomic_flag 一種最簡單的原子布爾類型，只支持兩種操作，test-and-set 和 clear。而 std::atomic 是模板類，一個模板類型為 T 的原子對象中封裝了一個類型為 T 的值，并且C++11 標準中除了定義基本 std::atomic 模板類型外，還提供了針對整形(integral)和指針類型的特化實現，提供了大量的 API，極大地方便了開發者使用。下面我分別介紹基于 std::atomic_flag 和 std::atomic 的 C 風格 API。
基于 std::atomic_flag 類型的 C 風格 API
atomic_flag_test_and_set
bool atomic_flag_test_and_set (
volatile atomic_flag*
obj) noexcept;
bool atomic_flag_test_and_set (atomic_flag* obj) noexcept;
檢測并設置 std::atomic_flag 的值，并返回 std::atomic_flag 的舊值，和 std::atomic::test_and_set() 成員函數的功能相同，整個過程也是原子的，默認的內存序為memory_order_seq_cst。
atomic_flag_test_and_set_explicit
bool atomic_flag_test_and_set (
volatile atomic_flag*
obj, memory_order sync) noexcept;
bool atomic_flag_test_and_set (atomic_flag* obj, memory_order sync) noexcept;
檢測并設置 std::atomic_flag 的值，并返回 std::atomic_flag 的舊值，和 std::atomic::test_and_set() 成員函數的功能相同，整個過程也是原子的。sync 參數指定了內存序（Memory Order），可能的取值如下：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_flag_clear
void atomic_flag_clear (
volatile atomic_flag*
obj) noexcept;
void atomic_flag_clear (atomic_flag* obj) noexcept;
清除 std::atomic_flag 對象，并設置它的值為 false，和 std::atomic::clear() 成員函數的功能相同，整個過程也是原子的，默認的內存序為memory_order_seq_cst。
atomic_flag_clear_explicit
void atomic_flag_clear (
volatile atomic_flag*
obj, memory_order sync) noexcept;
void atomic_flag_clear (atomic_flag* obj, memory_order sync) noexcept;
清除 std::atomic_flag 對象，并設置它的值為 false，和 std::atomic::clear() 成員函數的功能相同，整個過程也是原子的，sync 參數指定了內存序（Memory Order），可能的取值如下：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
基于 std::atomic 模板類型的 C 風格 API
atomic_is_lock_free
template (1) template <class T> bool atomic_is_lock_free (const volatile atomic<T>* obj) noexcept;
template <class T> bool atomic_is_lock_free (const atomic<T>* obj) noexcept;
overloads (2) bool atomic_is_lock_free (const volatile A* obj) noexcept;
bool atomic_is_lock_free (const A* obj) noexcept;
判斷該 std::atomic 對象是否具備 lock-free 的特性。如果某個對象滿足 lock-free 特性，在多個線程訪問該對象時不會導致線程阻塞。(可能使用某種事務內存transactional memory方法實現 lock-free 的特性)
。
atomic_init
template (1) template <class T> void atomic_init (volatile atomic<T>* obj, T val) noexcept;
template <class T> void atomic_init (atomic<T>* obj, T val) noexcept;
overloads (2) void atomic_init (volatile A* obj, T val) noexcept;
void atomic_init (A* obj, T val) noexcept;
初始化原子對象。
val 指定原子對象的初始值。如果對一個已初始化的原子對象再次調用 atomic_init()，則會導致未定義行為(undefined behavior)，如果你想修改原子對象的值，應該使用 std::atomic_store();
atomic_store
template (1) template <class T> void atomic_store (volatile atomic<T>* obj, T val) noexcept;
template <class T> void atomic_store (atomic<T>* obj, T val) noexcept;
overloads (2) void atomic_store (volatile A* obj, T val) noexcept;
void atomic_store (A* obj, T val) noexcept;
修改原子對象的值，默認的內存序為memory_order_seq_cst。該函數相當于 std::atomic 對象的 store 或者operator=() 成員函數，如果你需要顯式指定內存序，應該使用atomic_store_explicit。 atomic_store_explicit 修改原子對象的值。該函數相當于 std::atomic 對象的 store 或者operator=() 成員函數 ，sync 指定了內存序，可取的參數為：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_release Release memory_order_seq_cst Sequentially consistent
atomic_load
template (1) template <class T> T atomic_load (const volatile atomic<T>* obj) noexcept;
template <class T> T atomic_load (const atomic<T>* obj) noexcept;
overloads (2) T atomic_load (const volatile A* obj) noexcept;
T atomic_load (const A* obj) noexcept;
讀取被封裝的值， 默認的內存序為memory_order_seq_cst。該函數與 std::atomic 對象的atomic::load()和atomic::operator T() 成員函數等價。 atomic_load_explicit
template (1) template <class T>
T atomic_load_explicit (const volatile atomic<T>* obj, memory_order sync) noexcept;
template <class T>
T atomic_load_explicit (const atomic<T>* obj, memory_order sync) noexcept;
overloads (2) T atomic_load_explicit (const volatile A* obj, memory_order sync) noexcept;
T atomic_load_explicit (const A* obj, memory_order sync) noexcept;
讀取被封裝的值，參數 sync 設置內存序(Memory Order)，可能的取值如下：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_seq_cst Sequentially consistent
該函數與 std::atomic 對象的atomic::load() 成員函數等價。 atomic_exchange
template (1) template <class T> T atomic_exchange (volatile atomic<T>* obj, T val) noexcept;
template <class T> T atomic_exchange (atomic<T>* obj, T val) noexcept;
overloads (2) T atomic_exchange (volatile A* obj, T val) noexcept;
T atomic_exchange (A* obj, T val) noexcept;
讀取并修改被封裝的值，exchange 會將 val 指定的值替換掉之前該原子對象封裝的值，并返回之前該原子對象封裝的值，整個過程是原子的(因此exchange 操作也稱為read-modify-write 操作)。
該函數與 std::atomic 對象的atomic::exchange() 成員函數等價。 atomic_exchange_explicit
template (1) template <class T>
T atomic_store_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept;
template <class T>
T atomic_store_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
overloads (2) T atomic_store_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_store_explicit (A* obj, T val, memory_order sync) noexcept;
讀取并修改被封裝的值，exchange 會將 val 指定的值替換掉之前該原子對象封裝的值，并返回之前該原子對象封裝的值，整個過程是原子的(因此exchange 操作也稱為read-modify-write 操作)。sync參數指定內存序(Memory Order)，可能的取值如下：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_compare_exchange_weak
template (1) template <class T>
bool atomic_compare_exchange_weak (volatile atomic<T>* obj, T* expected, T val) noexcept;
template <class T>
bool atomic_compare_exchange_weak (atomic<T>* obj, T* expected, T val) noexcept;
overloads (2) bool atomic_compare_exchange_weak (volatile A* obj, T* expected, T val) noexcept;
bool atomic_compare_exchange_weak (A* obj, T* expected, T val) noexcept;
比較并交換被封裝的值(weak)與參數?expected 所指定的值是否相等，如果：
相等，則用 val 替換原子對象的舊值。 不相等，則用原子對象的舊值替換 expected ，因此調用該函數之后，如果被該原子對象封裝的值與參數?expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。
該函數通常會讀取原子對象封裝的值，如果比較為 true(即原子對象的值等于 expected)，則替換原子對象的舊值，但整個操作是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。
注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，所以某些情況下，對象的比較操作在使用 operator==() 判斷時相等，但 atomic_compare_exchange_weak 判斷時卻可能失敗，因為對象底層的物理內容中可能存在位對齊或其他邏輯表示相同但是物理表示不同的值(比如 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上兩者的表示并不相同)。
與 atomic_compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允許(spuriously 地)返回 false(即原子對象所封裝的值與參數expected 的物理內容相同，但卻仍然返回 false)，不過在某些需要循環操作的算法下這是可以接受的，并且在一些平臺下?compare_exchange_weak 的性能更好 。如果 atomic_compare_exchange_weak 的判斷確實發生了偽失敗(spurious failures)——即使原子對象所封裝的值與參數expected 的物理內容相同，但判斷操作的結果卻為 false，atomic_compare_exchange_weak 函數返回 false，并且參數expected 的值不會改變。
atomic_compare_exchange_weak_explicit
template (1) template <class T>
bool atomic_compare_exchange_weak_explicit (volatile atomic<T>* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
template <class T>
bool atomic_compare_exchange_weak_explicit (atomic<T>* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
overloads (2) bool atomic_compare_exchange_weak_explicit (volatile A* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
bool atomic_compare_exchange_weak_explicit (A* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
比較并交換被封裝的值(weak)與參數?expected 所指定的值是否相等，如果：
相等，則用 val 替換原子對象的舊值。 不相等，則用原子對象的舊值替換 expected ，因此調用該函數之后，如果被該原子對象封裝的值與參數?expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。
該函數通常會讀取原子對象封裝的值，如果比較為 true(即原子對象的值等于 expected)，則替換原子對象的舊值，但整個操作是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。
內存序（Memory Order）的選擇取決于比較操作結果，如果比較結果為 true(即原子對象的值等于 expected)，則選擇參數 success 指定的內存序，否則選擇參數 failure 所指定的內存序。
注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，所以某些情況下，對象的比較操作在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，因為對象底層的物理內容中可能存在位對齊或其他邏輯表示相同但是物理表示不同的值(比如 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上兩者的表示并不相同)。
與 atomic_compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允許(spuriously 地)返回 false(即原子對象所封裝的值與參數expected 的物理內容相同，但卻仍然返回 false)，不過在某些需要循環操作的算法下這是可以接受的，并且在一些平臺下?compare_exchange_weak 的性能更好 。如果 atomic_compare_exchange_weak 的判斷確實發生了偽失敗(spurious failures)——即使原子對象所封裝的值與參數expected 的物理內容相同，但判斷操作的結果卻為 false，atomic_compare_exchange_weak函數返回 false，并且參數expected 的值不會改變。
對于某些不需要采用循環操作的算法而言, 通常采用 atomic_compare_exchange_strong更好。另外，該函數的內存序由? sync 參數指定，可選條件如下：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_compare_exchange_strong
template (1) template <class T>
bool atomic_compare_exchange_strong (volatile atomic<T>* obj, T* expected, T val) noexcept;
template <class T>
bool atomic_compare_exchange_strong (atomic<T>* obj, T* expected, T val) noexcept;
overloads (2) bool atomic_compare_exchange_strong (volatile A* obj, T* expected, T val) noexcept;
bool atomic_compare_exchange_strong (A* obj, T* expected, T val) noexcept;
比較并交換被封裝的值(strong)與參數?expected 所指定的值是否相等，如果：
相等，則用 val 替換原子對象的舊值。 不相等，則用原子對象的舊值替換 expected ，因此調用該函數之后，如果被該原子對象封裝的值與參數?expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。
該函數通常會讀取原子對象封裝的值，如果比較為 true(即原子對象的值等于 expected)，則替換原子對象的舊值，但整個操作是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。
注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，所以某些情況下，對象的比較操作在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，因為對象底層的物理內容中可能存在位對齊或其他邏輯表示相同但是物理表示不同的值(比如 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上兩者的表示并不相同)。
與 atomic_compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允許(spuriously 地)返回 false，即原子對象所封裝的值與參數expected 的物理內容相同，比較操作一定會為 true。不過在某些平臺下，如果算法本身需要循環操作來做檢查， atomic_compare_exchange_weak 的性能會更好。
因此對于某些不需要采用循環操作的算法而言, 通常采用 atomic_compare_exchange_strong 更好。
atomic_compare_exchange_strong_explicit
template (1) template <class T>
bool atomic_compare_exchange_strong_explicit (volatile atomic<T>* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
template <class T>
bool atomic_compare_exchange_strong_explicit (atomic<T>* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
overloads (2) bool atomic_compare_exchange_strong_explicit (volatile A* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
bool atomic_compare_exchange_strong_explicit (A* obj,T* expected, T val, memory_order success, memory_order failure) noexcept;
比較并交換被封裝的值(strong)與參數?expected 所指定的值是否相等，如果：
相等，則用 val 替換原子對象的舊值。 不相等，則用原子對象的舊值替換 expected ，因此調用該函數之后，如果被該原子對象封裝的值與參數?expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。
該函數通常會讀取原子對象封裝的值，如果比較為 true(即原子對象的值等于 expected)，則替換原子對象的舊值，但整個操作是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。
內存序（Memory Order）的選擇取決于比較操作結果，如果比較結果為 true(即原子對象的值等于 expected)，則選擇參數 success 指定的內存序，否則選擇參數 failure 所指定的內存序。
注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，所以某些情況下，對象的比較操作在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，因為對象底層的物理內容中可能存在位對齊或其他邏輯表示相同但是物理表示不同的值(比如 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上兩者的表示并不相同)。
與atomic_compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允許(spuriously 地)返回 false，即原子對象所封裝的值與參數expected 的物理內容相同，比較操作一定會為 true。不過在某些平臺下，如果算法本身需要循環操作來做檢查， atomic_compare_exchange_weak 的性能會更好。
因此對于某些不需要采用循環操作的算法而言, 通常采用 atomic_compare_exchange_strong 更好。另外，該函數的內存序由? sync 參數指定，可選條件如下：
Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_fetch_add
template (integral) (1) template <class T> T atomic_fetch_add (volatile atomic<T>* obj, T val) noexcept;
template <class T> T atomic_fetch_add (atomic<T>* obj, T val) noexcept;
template (pointer) (2) template <class U> U* atomic_fetch_add (volatile atomic<U*>* obj, ptrdiff_t val) noexcept;
template <class U> U* atomic_fetch_add (atomic<U*>* obj, ptrdiff_t val) noexcept;
overloads (3) T atomic_fetch_add (volatile A* obj, M val) noexcept;
T atomic_fetch_add (A* obj, M val) noexcept;
將原子對象的封裝值加 val，并返回原子對象的舊值（適用于整形和指針類型的 std::atomic 特化版本），整個過程是原子的。該函數默認內存序為 memory_order_seq_cst。 該函數等價于 std::atomic 對象的atomic::fetch_add和 atomic::operator+= 成員函數。
atomic_fetch_add_explicit
template (integral) (1) template <class T>
T atomic_fetch_add_explicit (volatile atomic<T>* obj,T val, memory_order sync) noexcept;
template <class T>
T atomic_fetch_add_explicit (atomic<T>* obj,T val, memory_order sync) noexcept;
template (pointer) (2) template <class U>
U* atomic_fetch_add_explicit (volatile atomic<U*>* obj,ptrdiff_t val, memory_order sync) noexcept;
template <class U>
U* atomic_fetch_add_explicit (atomic<U*>* obj,ptrdiff_t val, memory_order sync) noexcept;
overloads (3) T atomic_fetch_add_explicit (volatile A* obj, M val, memory_order sync) noexcept;
T atomic_fetch_add_explicit (A* obj, M val, memory_order sync) noexcept;
將原子對象的封裝值加 val，并返回原子對象的舊值（適用于整形和指針類型的 std::atomic 特化版本），整個過程是原子的。 該函數等價于 std::atomic 對象的atomic::fetch_add成員函數。sync 參數指定內存序： Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_fetch_sub
template (integral) (1) template <class T> T atomic_fetch_sub (volatile atomic<T>* obj, T val) noexcept;
template <class T> T atomic_fetch_sub (atomic<T>* obj, T val) noexcept;
template (pointer) (2) template <class U> U* atomic_fetch_sub (volatile atomic<U*>* obj, ptrdiff_t val) noexcept;
template <class U> U* atomic_fetch_sub (atomic<U*>* obj, ptrdiff_t val) noexcept;
overloads (3) T atomic_fetch_sub (volatile A* obj, M val) noexcept;
T atomic_fetch_sub (A* obj, M val) noexcept;
將原子對象的封裝值減 val，并返回原子對象的舊值（適用于整形和指針類型的 std::atomic 特化版本），整個過程是原子的。
atomic_fetch_sub_explicit
template (integral) (1) template <class T>
T atomic_fetch_sub_explicit (volatile atomic<T>* obj,T val, memory_order sync) noexcept;
template <class T>
T atomic_fetch_sub_explicit (atomic<T>* obj,T val, memory_order sync) noexcept;
template (pointer) (2) template <class U>
U* atomic_fetch_sub_explicit (volatile atomic<U*>* obj,ptrdiff_t val, memory_order sync) noexcept;
template <class U>
U* atomic_fetch_sub_explicit (atomic<U*>* obj,ptrdiff_t val, memory_order sync) noexcept;
overloads (3) T atomic_fetch_sub_explicit (volatile A* obj, M val, memory_order sync) noexcept;
T atomic_fetch_sub_explicit (A* obj, M val, memory_order sync) noexcept;
將原子對象的封裝值減 val，并返回原子對象的舊值（適用于整形和指針類型的 std::atomic 特化版本），整個過程是原子的。
該函數等價于 std::atomic 對象的atomic::fetch_sub成員函數。sync 參數指定內存序： Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_fetch_and
emplate (integral) (1) template <class T> T atomic_fetch_and (volatile atomic<T>* obj, T val) noexcept;
template <class T> T atomic_fetch_and (atomic<T>* obj, T val) noexcept;
overloads (2) T atomic_fetch_and (volatile A* obj, T val) noexcept;
T atomic_fetch_and (A* obj, T val) noexcept;
將原子對象的封裝值按位與 val，并返回原子對象的舊值（只適用于整型的 std::atomic 特化版本），整個過程是原子的。
atomic_fetch_and_explicit
template (integral) (1) template <class T>
T atomic_fetch_and_explicit (volatile atomic<T>* obj,T val, memory_order sync) noexcept;
template <class T>
T atomic_fetch_and_explicit (atomic<T>* obj,T val, memory_order sync) noexcept;
overloads (2) T atomic_fetch_and_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_fetch_and_explicit (A* obj, T val, memory_order sync) noexcept;
將原子對象的封裝值按位與 val，并返回原子對象的舊值（只適用于整型的 std::atomic 特化版本），整個過程是原子的。
該函數等價于 std::atomic 對象的atomic::fetch_and成員函數。sync 參數指定內存序： Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_fetch_or
template (integral) (1) template <class T> T atomic_fetch_or (volatile atomic<T>* obj, T val) noexcept;
template <class T> T atomic_fetch_or (atomic<T>* obj, T val) noexcept;
overloads (2) T atomic_fetch_or (volatile A* obj, T val) noexcept;
T atomic_fetch_or (A* obj, T val) noexcept;
將原子對象的封裝值按位或 val，并返回原子對象的舊值（只適用于整型的 std::atomic 特化版本），整個過程是原子的。
atomic_fetch_or_explicit
template (integral) (1) template <class T>
T atomic_fetch_or_explicit (volatile atomic<T>* obj,T val, memory_order sync) noexcept;
template <class T>
T atomic_fetch_or_explicit (atomic<T>* obj,T val, memory_order sync) noexcept;
overloads (2) T atomic_fetch_or_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_fetch_or_explicit (A* obj, T val, memory_order sync) noexcept;
A
將原子對象的封裝值按位或 val，并返回原子對象的舊值（只適用于整型的 std::atomic 特化版本），整個過程是原子的。
該函數等價于 std::atomic 對象的atomic::fetch_or成員函數。sync 參數指定內存序： Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
atomic_fetch_xor
template (integral) (1) template <class T> T atomic_fetch_xor (volatile atomic<T>* obj, T val) noexcept;
template <class T> T atomic_fetch_xor (atomic<T>* obj, T val) noexcept;
overloads (2) T atomic_fetch_xor (volatile A* obj, T val) noexcept;
T atomic_fetch_xor (A* obj, T val) noexcept;
將原子對象的封裝值按位異或 val，并返回原子對象的舊值（只適用于整型的 std::atomic 特化版本），整個過程是原子的。
atomic_fetch_xor_explicit
template (integral) (1) template <class T>
T atomic_fetch_xor_explicit (volatile atomic<T>* obj,T val, memory_order sync) noexcept;
template <class T>
T atomic_fetch_xor_explicit (atomic<T>* obj,T val, memory_order sync) noexcept;
overloads (2) T atomic_fetch_xor_explicit (volatile A* obj, T val, memory_order sync) noexcept;
T atomic_fetch_xor_explicit (A* obj, T val, memory_order sync) noexcept;
將原子對象的封裝值按位異或 val，并返回原子對象的舊值（只適用于整型的 std::atomic 特化版本），整個過程是原子的。
該函數等價于 std::atomic 對象的atomic::fetch_xor成員函數。sync 參數指定內存序： Memory Order 值Memory Order 類型 memory_order_relaxed Relaxed memory_order_consume Consume memory_order_acquire Acquire memory_order_release Release memory_order_acq_rel Acquire/Release memory_order_seq_cst Sequentially consistent
與原子對象初始化相關的宏 此外，還有兩個宏值得關注，他們分別是：
ATOMIC_VAR_INIT(val) 初始化 std::atomic 對象。
ATOMIC_FLAG_INIT 初始化 std::atomic_flag 對象。
總結
以上是生活随笔 為你收集整理的C++11 并发指南六(atomic 类型详解四 C 风格原子操作介绍) 的全部內容，希望文章能夠幫你解決所遇到的問題。
如果覺得生活随笔 網站內容還不錯，歡迎將生活随笔 推薦給好友。
