std::atomic<T>::operator++,++(int),--,--(int)
| member only of atomic<Integral > specializations |
||
T operator++() noexcept;
|
(1) | (since C++11) |
T operator++() volatile noexcept;
|
(2) | (since C++11) |
T operator++( int ) noexcept;
|
(3) | (since C++11) |
T operator++( int ) volatile noexcept;
|
(4) | (since C++11) |
T operator--() noexcept;
|
(5) | (since C++11) |
T operator--() volatile noexcept;
|
(6) | (since C++11) |
T operator--( int ) noexcept;
|
(7) | (since C++11) |
T operator--( int ) volatile noexcept;
|
(8) | (since C++11) |
| member only of atomic<T*> partial specialization |
||
T* operator++() noexcept;
|
(9) | (since C++11) |
T* operator++() volatile noexcept;
|
(10) | (since C++11) |
T* operator++( int ) noexcept;
|
(11) | (since C++11) |
T* operator++( int ) volatile noexcept;
|
(12) | (since C++11) |
T* operator--() noexcept;
|
(13) | (since C++11) |
T* operator--() volatile noexcept;
|
(14) | (since C++11) |
T* operator--( int ) noexcept;
|
(15) | (since C++11) |
T* operator--( int ) volatile noexcept;
|
(16) | (since C++11) |
Atomically increments or decrements the current value. The operation is read-modify-write operation.
operator++()performs atomic pre-increment. Equivalent toreturn fetch_add(1) + 1;.operator++(int)performs atomic post-increment. Equivalent toreturn fetch_add(1);.operator--()performs atomic pre-decrement. Equivalent toreturn fetch_sub(1) - 1;.operator--(int)performs atomic post-decrement. Equivalent toreturn fetch_sub(1);.
T is not a complete object type, the program is ill-formed.|
It is deprecated if |
(since C++20) |
Return value
operator++() and operator--() return the value of the atomic variable after the modification. Formally, the result of incrementing/decrementing the value immediately preceding the effects of this function in the modification order of *this.
operator++(int) and operator--(int) return the value of the atomic variable before the modification. Formally, the value immediately preceding the effects of this function in the modification order of *this.
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.
Example
#include <atomic>
#include <chrono>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <random>
#include <string>
#include <thread>
std::atomic<int> atomic_count{0};
std::mutex cout_mutex;
int completed_writes{0};
constexpr int global_max_count{72};
constexpr int writes_per_line{8};
constexpr int max_delay{100};
template<int Max>
int random_value()
{
static std::uniform_int_distribution<int> distr{1, Max};
static std::random_device engine;
static std::mt19937 noise{engine()};
static std::mutex rand_mutex;
std::lock_guard lock{rand_mutex};
return distr(noise);
}
int main()
{
auto work = [](const std::string id)
{
for (int count{}; (count = ++atomic_count) <= global_max_count;)
{
std::this_thread::sleep_for(
std::chrono::milliseconds(random_value<max_delay>()));
// print thread `id` and `count` value
{
std::lock_guard lock{cout_mutex};
const bool new_line = ++completed_writes % writes_per_line == 0;
std::cout << id << std::setw(3) << count << " "
<< (new_line ? "\n" : "") << std::flush;
}
}
};
std::jthread j1(work, ""), j2(work, ""), j3(work, ""), j4(work, "");
}
Possible output:
2 1 5 7 4 6 3 8
11 9 13 10 14 12 16 19
15 18 21 22 17 25 24 26
20 29 27 23 31 33 32 28
30 37 34 35 36 41 40 39
38 43 42 46 48 47 50 45
44 53 54 49 55 51 57 58
52 56 61 59 60 62 64 63
68 66 65 71 67 70 69 72
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| P0558R1 | C++11 | arithmetic permitted on pointers to (possibly cv-qualified) void or function
|
made ill-formed |
See also
| atomically adds the argument to the value stored in the atomic object and obtains the value held previously (public member function) | |
| atomically subtracts the argument from the value stored in the atomic object and obtains the value held previously (public member function) | |
| adds to or subtracts from the atomic value (public member function) | |
| performs bitwise AND, OR, XOR with the atomic value (public member function) |