C++ Atomic::fetch_add() function

---

---

The C++ std::atomic::fetch_add() function is used to add a specified value to an atomic object and returns the value that the object held before the addition. This function prevent race conditions, ensuring that multiple threads can safely update shared variables without causing data corruption.

Syntax

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

T fetch_add (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_add (T val, memory_order sync = memory_order_seq_cst) noexcept;
or
T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) noexcept;

Parameters

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

Return Value

This function returns the contained value before the call.

Exceptions

This member function never throws exceptions.

Example

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

#include <iostream>
#include <atomic>
int main()
{
    std::atomic<int> x(11);
    int y = x.fetch_add(2);
    std::cout << "Old value: " << y << std::endl;
    std::cout << "New value: " << x << std::endl;
    return 0;
}

Output

Output of the above code is as follows −

Old value: 11
New value: 13

Example

Consider the following example, where we are going to use fetch_add() function in the loop.

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>
int main()
{
    std::atomic<int> a(1);
    std::vector<std::thread> b;
    for (int x = 0; x < 3; ++x) {
        b.emplace_back([&a]() {
            for (int y = 0; y < 10; ++y) {
                a.fetch_add(1);
            }
        });
    }
    for (auto& thread : b) {
        thread.join();
    }
    std::cout << "Result : " << a << std::endl;
    return 0;
}

Output

Following is the output of the above code −

Result : 31

Example

Let's look at the following example, where we are going to add the negative value.

#include <iostream>
#include <atomic>
int main()
{
    std::atomic<int> x(12);
    int a = x.fetch_add(-6);
    std::cout << "Result after fetch_add: " << a << std::endl;
    std::cout << "Atomic variable after fetch_add: " << x << std::endl;
    return 0;
}

Output

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

Result after fetch_add: 12
Atomic variable after fetch_add: 6