std::atomic::operator++,++(int),--,--(int)

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Atomic operations library

Types

atomic (C++11)

atomic_is_lock_free (C++11)

Functions

atomic_storeatomic_store_explicit (C++11)(C++11)

atomic_loadatomic_load_explicit (C++11)(C++11)

atomic_exchangeatomic_exchange_explicit (C++11)(C++11)

atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11)

atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11)

atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11)

atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11)

atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11)

atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11)

Atomic flags

atomic_flag (C++11)

atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)

atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)

Initialization

atomic_init (C++11)

ATOMIC_VAR_INIT (C++11)

ATOMIC_FLAG_INIT (C++11)

Memory ordering

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

std::atomic

Member functions

atomic::atomic

atomic::operator=

atomic::is_lock_free

atomic::store

atomic::load

atomic::operator T

atomic::exchange

atomic::compare_exchange

Specialized member functions

atomic::fetch_add

atomic::fetch_sub

atomic::fetch_and

atomic::fetch_or

atomic::fetch_xor

atomic::operator++atomic::operator++(int)atomic::operator--atomic::operator--(int)

atomic::operator+=atomic::operator-=atomic::operator&=atomic::operator|=atomic::operator^=

 

T operator++(); T operator++() volatile;	(1)	(member only of atomic<Integral> template specialization) (since C++11)
T* operator++(); T* operator++() volatile;	(1)	(member only of atomic<T*> template specialization) (since C++11)
T operator++( int ); T operator++( int ) volatile;	(2)	(member only of atomic<Integral> template specialization) (since C++11)
T* operator++( int ); T* operator++( int ) volatile;	(2)	(member only of atomic<T*> template specialization) (since C++11)
T operator--(); T operator--() volatile;	(3)	(member only of atomic<Integral> template specialization) (since C++11)
T* operator--(); T* operator--() volatile;	(3)	(member only of atomic<T*> template specialization) (since C++11)
T operator--( int ); T operator--( int ) volatile;	(4)	(member only of atomic<Integral> template specialization) (since C++11)
T* operator--( int ); T* operator--( int ) volatile;	(4)	(member only of atomic<T*> template specialization) (since C++11)

Atomically increments or decrements the current value. The operation is read-modify-write operation.

1) Performs atomic pre-increment. Equivalent to fetch_add(1)+1.

2) Performs atomic post-increment. Equivalent to fetch_add(1).

3) Performs atomic pre-decrement. Equivalent to fetch_sub(1)-1

4) Performs atomic post-decrement. Equivalent to fetch_sub(1).

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.

Parameters

(none)

Return value

1,3) The value of the atomic variable after the modification.

2,4) The value of the atomic variable before the modification.

Exceptions

noexcept specification:  

noexcept

  

Notes

Unlike most pre-increment and pre-decrement operators, the pre-increment and pre-decrement operators for atomic types do not return a reference to the modified object. They return a copy of the stored value instead.

See also

fetch_add (C++11)	atomically adds the argument to the value stored in the atomic object and obtains the value held previously (public member function)
fetch_sub (C++11)	atomically subtracts the argument from the value stored in the atomic object and obtains the value held previously (public member function)
operator+=operator-=operator&=operator|=operator^=	adds, subtracts, or performs bitwise AND, OR, XOR with the atomic value (public member function)