前面三篇文章《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，並且參數
-
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，並且參數
-
對於某些不需要采用循環操作的算法而言, 通常采用
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 對象。
