std::atomic::fetch_add

T fetch_add( T arg, 
             std::memory_order order = std::memory_order_seq_cst );

T fetch_add( T arg, 
             std::memory_order order = std::memory_order_seq_cst ) volatile;

T* fetch_add( std::ptrdiff_t arg, 
              std::memory_order order = std::memory_order_seq_cst );

T* fetch_add( std::ptrdiff_t arg, 
              std::memory_order order = std::memory_order_seq_cst ) volatile;

Atomically replaces the current value with the result of arithmetic addition of the value and arg. The operation is read-modify-write operation. Memory is affected according to the value of order.

For signed Integral types, arithmetic is defined to use two’s complement representation. There are no undefined results. For T* types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

Parameters

Return value

The value immediately preceding the effects of this function in the modification order of *this.

Exceptions

Example

#include <iostream>
#include <thread>
#include <atomic>
 
std::atomic<long long> data;
void do_work()
{
    data.fetch_add(1, std::memory_order_relaxed);
}
 
int main()
{
    std::thread th1(do_work);
    std::thread th2(do_work);
    std::thread th3(do_work);
    std::thread th4(do_work);
    std::thread th5(do_work);
 
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();
 
    std::cout << "Result:" << data << '\n';
}

Result:5

See also