public member function
<atomic>

std::atomic::store

void store (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;void store (T val, memory_order sync = memory_order_seq_cst) noexcept;
Modify contained value
Replaces the contained value with val.

The operation is atomic and follows the memory ordering specified by sync.

Parameters

val
Value to copy to the contained object.
T is atomic's template parameter (the type of the contained value).
sync
Synchronization mode for the operation.
This shall be one of these possible values of the enum type memory_order:
valuememory orderdescription
memory_order_relaxedRelaxedNo synchronization of side effects.
memory_order_releaseReleaseSynchronizes side effects with the next consume or acquire operation.
memory_order_seq_cstSequentially consistentSynchronizes all visible side effects with the other sequentially consistent operations, following a single total order.

Return value

none

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// atomic::load/store example
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread

std::atomic<int> foo (0);

void set_foo(int x) {
  foo.store(x,std::memory_order_relaxed);     // set value atomically
}

void print_foo() {
  int x;
  do {
    x = foo.load(std::memory_order_relaxed);  // get value atomically
  } while (x==0);
  std::cout << "foo: " << x << '\n';
}

int main ()
{
  std::thread first (print_foo);
  std::thread second (set_foo,10);
  first.join();
  second.join();
  return 0;
}

Output:
foo: 10


Data races

No data races (atomic operation). Memory order specified by argument sync.

Exception safety

No-throw guarantee: never throws exceptions.

See also