(1) | (since C++11) (member only of `atomic<` template specialization) | |

T operator+=( T arg ); | ||

T operator+=( T arg ) volatile; | ||

(1) | (since C++11) (member only of `atomic<T*>` template specialization) | |

T* operator+=( std::ptrdiff_t arg ); | ||

T* operator+=( std::ptrdiff_t arg ) volatile; | ||

(2) | (since C++11) (member only of `atomic<` template specialization) | |

T operator-=( T arg ); | ||

T operator-=( T arg ) volatile; | ||

(2) | (since C++11) (member only of `atomic<T*>` template specialization) | |

T* operator-=( std::ptrdiff_t arg ); | ||

T* operator-=( std::ptrdiff_t arg ) volatile; | ||

(3) | (since C++11) (member only of `atomic<` template specialization) | |

T operator&=( T arg ); | ||

T operator&=( T arg ) volatile; | ||

(4) | (since C++11) (member only of `atomic<` template specialization) | |

T operator|=( T arg ); | ||

T operator|=( T arg ) volatile; | ||

(5) | (since C++11) (member only of `atomic<` template specialization) | |

T operator^=( T arg ); | ||

T operator^=( T arg ) volatile; |

Atomically replaces the current value with the result of computation involving the previous value and `arg`

. The operation is read-modify-write operation.

1) Performs atomic addition. Equivalent to

`fetch_add(arg)`

+ arg.
2) Performs atomic subtraction. Equivalent to

`fetch_sub(arg)`

- arg.
3) Performs atomic bitwise and. Equivalent to

`fetch_and(arg)`

& arg.
4) Performs atomic bitwise or. Equivalent to

`fetch_or(arg)`

| arg.
5) Performs atomic bitwise exclusive or. Equivalent to

`fetch_xor(arg)`

^ arg.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.

arg | - | the argument for the arithmetic operation |

The resulting value (that is, the result of applying the corresponding binary operator to the value immediately preceding the effects of the corresponding member function in the modification order of `*this`

).

`noexcept`

specification: `noexcept`

Unlike most compound assignment operators, the compound assignment operators for atomic types do not return a reference to their left-hand arguments. They return a copy of the stored value instead.

increments or decrements the atomic value by one (public member function) |

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/atomic/atomic/operator_arith2