Question

I am trying to use std::atomic library.

1. What’s the difference between specialized and non-specialized atomic
   member functions?
2. What’s the difference (if there is any) between following functions?
3. operator= stores a value into an atomic object (public member function) v.s. store (C++11) atomically replaces the value of the atomic object with a non-atomic argument (public member function)
4. operator T() loads a value from an atomic object (public member function) v.s. load (C++11) atomically obtains the value of the atomic object (public member function).
5. operator+= v.s. fetch_add
6. operator-= v.s. fetch_sub
7. operator&= v.s. fetch_and
8. operator|= v.s. fetch_or
9. operator^= v.s. fetch_xor
10. What’s the downside of declare a variable as atomic v.s. a
    non-atomic variable. For example, what’s the downside of
    std::atomic<int> x v.s. int x? In other words, how much is the overhead of an atomic variable?
11. Which one has more overhead? An atomic variable, v.s. a normal
    variable protected by a mutex?

Here is the reference to my quesitons. http://en.cppreference.com/w/cpp/atomic/atomic

Answer 1

Not an expert, but I’ll try:

1. The specializations (for built-in types such as int) contain additional operations such as fetch_add. Non-specialized forms (user defined types) will not contain these.
2. operator= returns its argument, store does not. Also, non-operators allow you to specify a memory order. The standard says operator= is defined in terms of store.
3. Same as above, although it returns the value of load.
4. Same as above
5. Same as above
6. Same as above
7. Same as above
8. Same as above
9. Same as above
10. They do different things. It’s undefined behavior to use an int in the way you would use std::atomic_int.
11. You can assume the overhead is int <= std::atomic <= int and std::mutex where <= means ‘less overhead’. So it’s likely better than locking with a mutex (especially for built-in types), but worse than int.