How to declare a vector of atomic in C++

by

As described in this closely related question that was mentioned in the comments, std::atomic<T> isn’t copy-constructible, nor copy-assignable.

Object types that don’t have these properties cannot be used as elements of std::vector.

However, it should be possible to create a wrapper around the std::atomic<T> element that is copy-constructible and copy-assignable. It will have to use the load() and store() member functions of std::atomic<T> to provide construction and assignment (this is the idea described by the accepted answer to the question mentioned above):

#include <atomic>
#include <vector>

template <typename T>
struct atomwrapper
{
  std::atomic<T> _a;

  atomwrapper()
    :_a()
  {}

  atomwrapper(const std::atomic<T> &a)
    :_a(a.load())
  {}

  atomwrapper(const atomwrapper &other)
    :_a(other._a.load())
  {}

  atomwrapper &operator=(const atomwrapper &other)
  {
    _a.store(other._a.load());
  }
};

int main(void)
{
  std::vector<atomwrapper<int>> v_a;
  std::atomic<int> a_i(1);
  v_a.push_back(a_i);
  return 0;
}

EDIT: As pointed out correctly by Bo Persson, the copy operation performed by the wrapper is not atomic. It enables you to copy atomic objects, but the copy itself isn’t atomic. This means any concurrent access to the atomics must not make use of the copy operation. This implies that operations on the vector itself (e.g. adding or removing elements) must not be performed concurrently.

Example: If, say, one thread modifies the value stored in one of the atomics while another thread adds new elements to the vector, a vector reallocation may occur and the object the first thread modifies may be copied from one place in the vector to another. In that case there would be a data race between the element access performed by the first thread and the copy operation triggered by the second.

More Related Contents:

  1. Why do I get the same sequence for every run with std::random_device with mingw gcc4.8.1?
  2. Nice way to append a vector to itself
  3. Why is template argument deduction disabled with std::forward?
  4. What does the standard library guarantee about self move assignment?
  5. Where is the lock for a std::atomic?
  6. What do each memory_order mean?
  7. std::vector, default construction, C++11 and breaking changes
  8. Why is value taking setter member functions not recommended in Herb Sutter’s CppCon 2014 talk (Back to Basics: Modern C++ Style)?
  9. When do I really need to use atomic instead of bool? [duplicate]
  10. Is there any compiler barrier which is equal to asm(“” ::: “memory”) in C++11?
  11. Non-copyable elements in vector
  12. How to atomically update a maximum value?
  13. Why is the volatile qualifier used through out std::atomic?
  14. What is the default hash function used in C++ std::unordered_map?
  15. Why are std::atomic objects not copyable?
  16. C++11 STL containers and thread safety
  17. How do I erase elements from STL containers?
  18. What happens when you call data() on a std::vector?
  19. Do I have to use atomic for “exit” bool variable?
  20. Comparing 3 modern c++ ways to convert integral values to strings
  21. Can std::vector emplace_back copy construct from an element of the vector itself?
  22. Why can’t I replace std::map with std::unordered_map
  23. Understanding std::atomic::compare_exchange_weak() in C++11
  24. Why isn’t std::array::size static?
  25. error for hash function of pair of ints
  26. stl container with std::unique_ptr’s vs boost::ptr_container
  27. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  28. const auto std::initializer_list difference between Clang and GCC
  29. C++11 std::to_string(double) – No trailing zeros
  30. C++ priority_queue with lambda comparator error

Leave a Comment