C++ Atomic::fetch_xor() function

---

---

The C++ std::atomic::fetch_xor() function is an atomic operation that is used to perform an atomic bitwise XOR operation between the atomic variable and the specified value. This function ensures thread safe manipulations of atomic variables, preventing data races.

This function has 2 variants: one with a specified memory order, which controls how memory operations are synchronized, and the another is default memory order.

Syntax

Following is the syntax for std::atomic::fetch_xor() function.

T fetch_xor (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_xor (T val, memory_order sync = memory_order_seq_cst) noexcept;

Parameters

• val − It indicates the value to apply.
• sync − It indicates the synchronization mode for the operation.

Return Value

This function returns the contained value before the call.

Exceptions

This function never throws exceptions.

Example

In the following example, we are going to consider the basic usage of fetch_xor() function.

#include <iostream>
#include <atomic>
int main()
{
    std::atomic<int> x(0b1111);
    int result = x.fetch_xor(0b1010);
    std::cout << "Initial Value:  " << result << std::endl;
    std::cout << "Final Value : " << x.load() << std::endl;
    return 0;
}

Output

Output of the above code is as follows −

Initial Value:  15
Final Value : 5

Example

Consider the following example, where we are going to use the loop to flip specific bits of the atomic variable. On each iteration fetch_xor() function is invoked.

#include <iostream>
#include <atomic>
int main()
{
    std::atomic<int> x(0);
    for (int i = 0; i < 4; ++i) {
        int a = x.fetch_xor(1 << i);
        std::cout << "Result after " <<  i <<  " iteration : " << a << std::endl;
    }
    std::cout << "Final value : " << x.load() << std::endl;
    return 0;
}

Output

Following is the output of the above code −

Result after 0 iteration : 0
Result after 1 iteration : 1
Result after 2 iteration : 3
Result after 3 iteration : 7
Final value : 15

Example

Let's look at the following example, where we are going to use the fetch_xor() in multi threaded environment.

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
std::atomic<int> x(0b10101);
void a(int b)
{
    x.fetch_xor(b);
}
int main()
{
    std::vector<std::thread> x1;
    for (int i = 0; i < 4; ++i) {
        x1.emplace_back(a, 1 << i);
    }
    for (auto& t : x1) {
        t.join();
    }
    std::cout << "Result : " << x.load() << std::endl;
    return 0;
}

Output

If we run the above code it will generate the following output −

Result : 26