C++ Atomic::fetch_and() function

---

---

The C++ std::atomic::fetch_and() function is used to perform an atomic bitwise AND operation on the value of an atomic object. It modifies the atomic variable by applying a bitwise AND with the given argument, ensuring thread safety without using the locks. It returns the original value before the operation.

Syntax

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

T fetch_and (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_and (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_and() function.

#include <iostream>
#include <atomic>
int main()
{
    std::atomic<int> x(0b1100);
    int y = x.fetch_and(0b1010);
    std::cout << "Original value: " << y << std::endl;
    std::cout << "New value: " << x.load() << std::endl;
    return 0;
}

Output

Output of the above code is as follows −

Original value: 12
New value: 8

Example

Consider the following example, where we are going to use multiple fetch_and() and observing the output.

#include <iostream>
#include <atomic>
int main()
{
    std::atomic<int> x(0b00110);
    int a = x.fetch_and(0b10011);
    int b = x.fetch_and(0b10000);
    std::cout << "Result after first fetch_and: " << a << std::endl;
    std::cout << "Result after second fetch_and: " << b << std::endl;
    std::cout << "Final value: " << x.load() << std::endl;
    return 0;
}

Output

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

Result after first fetch_and: 6
Result after second fetch_and: 2
Final value: 0

Example

Let's look at the following example, where we are going to use the fetch_and() with std::memory_order_relaxed.

#include <iostream>
#include <atomic>
#include <thread>
std::atomic<int> x(0b0101);
void a()
{
    int b = x.fetch_and(0b0100, std::memory_order_relaxed);
    std::cout << "Old value: " << b << ", New value: " << x.load() << '\n';
}
int main()
{
    std::thread t1(a);
    t1.join();
    return 0;
}

Output

Following is the output of the above code −

Old value: 5, New value: 4