# std::atomic_ref<T>::atomic_ref

From cppreference.com
< cpp‎ | atomic‎ | atomic ref

explicit atomic_ref( T& obj ); | (1) | (since C++20)
atomic_ref( const atomic_ref& ref ) noexcept; | (2) | (since C++20)

Constructs a new `atomic_ref` object.

1) Constructs an `atomic_ref` object referencing the object `obj`. The behavior is undefined if `obj` is not aligned to `required_alignment`.
2) Constructs an `atomic_ref` object referencing the object referenced by `ref`.

### Parameters

obj | - | object to reference
ref | - | another `atomic_ref` object to copy from

### Example

The program increments the values in a container using several threads. Then the final sum is printed. Non-atomic access may "loss" the results of some operations due to data-races.

Run this code

    #include <atomic>
    #include <thread>
    #include <vector>
    #include <numeric>
    #include <iostream>

    int main()
    {
        using Data = std::vector<char>;

        auto inc_atomically = [](Data& data) {
            for (Data::value_type& x : data) {
                auto xx = std::atomic_ref<Data::value_type>(x);
                ++xx;  // atomic read-modify-write
            }
        };

        auto inc_directly = [](Data& data) {
            for (Data::value_type& x : data)
                ++x;
        };

        auto test_run = [](const auto Fun) {
            Data data(10'000'000);
            {
                std::jthread j1 {Fun, std::ref(data)};
                std::jthread j2 {Fun, std::ref(data)};
                std::jthread j3 {Fun, std::ref(data)};
                std::jthread j4 {Fun, std::ref(data)};
            }
            std::cout << "sum = " << std::accumulate(cbegin(data), cend(data), 0) << '\n';
        };

        test_run(inc_atomically);
        test_run(inc_directly);
    }

Possible output:

    sum = 40000000
    sum = 39994973

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/atomic/atomic_ref/atomic_ref&oldid=136854"