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

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

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)

Filesystem library (C++17)

Technical Specifications

Atomic operations library

Types

atomic (C++11)

atomic_ref (C++20)

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_is_lock_free (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_ref

Member functions

atomic_ref::atomic_ref

atomic_ref::operator=

atomic_ref::is_lock_free

atomic_ref::store

atomic_ref::load

atomic_ref::operator T

atomic_ref::exchange

atomic_ref::compare_exchange_strongatomic_ref::compare_exchange_weak

Constants

atomic_ref::is_always_lock_free

atomic_ref::required_alignment

Specialized member functions

atomic_ref::fetch_add

atomic_ref::fetch_sub

atomic_ref::fetch_and

atomic_ref::fetch_or

atomic_ref::fetch_xor

atomic_ref::operator++atomic_ref::operator++(int)atomic_ref::operator--atomic_ref::operator--(int)

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

member only of atomic_ref<Integral> and atomic_ref<T*> template specializations
value_type operator++() const noexcept;	(1)	(since C++20)
value_type operator++(int) const noexcept;	(2)	(since C++20)
value_type operator--() const noexcept;	(3)	(since C++20)
value_type operator--(int) const noexcept;	(4)	(since C++20)

Atomically increments or decrements the current value of the referenced object. These operations are read-modify-write operations.

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

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

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

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

For signed Integral types, arithmetic is defined to use twos 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. The program is ill-formed if T is not an object type.

Parameters

(none)

Return value

1,3) The value of the referenced object after the modification.

2,4) The value of the referenced object before the modification.

Notes

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

See also

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