`atomic` 结构

项目
07/05/2024

描述对 Ty 类型的存储值执行 atomic 操作的对象。

语法

template <class Ty>
struct atomic;

成员

成员	说明
构造函数
`atomic`	构造一个原子对象。
运算符
`atomic::operator Ty`	读取并返回存储的值。（`atomic::load`）
`atomic::operator=`	使用指定值替换存储值。（`atomic::store`）
`atomic::operator++`	增加存储值。仅由整型和指针专用化使用。
`atomic::operator+=`	将指定的值添加到存储的值。仅由整型和指针专用化使用。
`atomic::operator--`	逐量减小存储值。仅由整型和指针专用化使用。
`atomic::operator-=`	从存储的值减去指定的值。仅由整型和指针专用化使用。
`atomic::operator&=`	对指定值和存储值执行按位“与”(`&`)。仅由整型专用化使用。
`atomic::operator\|=`	对指定值和存储值执行按位“或”(`\|`)。仅由整型专用化使用。
`atomic::operator^=`	对指定值和存储值执行按位“异或”(`^`)。仅由整型专用化使用。
函数
`compare_exchange_strong`	对 `this` 执行 `atomic_compare_and_exchange` 操作并返回结果。
`compare_exchange_weak`	对 `this` 执行 `weak_atomic_compare_and_exchange` 操作并返回结果。
`fetch_add`	将指定的值添加到存储的值。
`fetch_and`	对指定值和存储值执行按位“与”(`&`)。
`fetch_or`	对指定值和存储值执行按位“或”(`\|`)。
`fetch_sub`	从存储的值减去指定的值。
`fetch_xor`	对指定值和存储值执行按位“异或”(`^`)。
`is_lock_free`	指定 `this` 上的`atomic`操作是否为无锁。如果对 `atomic` 类型的所有 `atomic` 操作都没有使用锁，则此类型为“无锁”。
`load`	读取并返回存储的值。
`store`	使用指定值替换存储值。

注解

类型 Ty 必须完全可复制。即，使用 memcpy 复制其字节必须生成一个与原始对象相等的有效 Ty 对象。 compare_exchange_weak 和 compare_exchange_strong 成员函数使用 memcmp 来确定两个 Ty 值是否相等。这些函数将不会使用 Ty-definedoperator==。 atomic 的成员函数使用 memcpy 复制类型 Ty 的值。

部分专用化 atomic<Ty*>，对所有指针类型都存在。通过专用化可将偏移量添加到托管的指针值或者从其中减去该偏移量。该算术运算采用类型为 ptrdiff_t 的参数，并根据 Ty 的大小调整该参数，以与普通地址算术保持一致。

对于除 bool 之外的每个整型类型都均存在专用化。每个专用化为原子算术和逻辑运算提供了一组丰富的方法。

atomic<char>
atomic<signed char>
atomic<unsigned char>
atomic<char16_t>
atomic<char32_t>
atomic<wchar_t>
atomic<short>

atomic<unsigned short>
atomic<int>
atomic<unsigned int>
atomic<long>
atomic<unsigned long>
atomic<long long>
atomic<unsigned long long>

整型专用化派生自相应的 atomic_integral 类型。例如，atomic<unsigned int> 派生自 atomic_uint。

要求

标头：<atomic>

命名空间：std

`atomic::atomic`

构造一个原子对象。

atomic();
atomic( const atomic& );
atomic( Ty Value ) noexcept;

参数

Value
初始化值。

注解

不能复制或移动原子对象。

作为 atomic<Ty> 的实例化的对象只能由接受 Ty 类型参数的构造函数进行初始化，而不能使用聚合初始化进行初始化。但是，atomic_integral 对象只能通过使用聚合初始化来进行初始化。

atomic<int> ai0 = ATOMIC_VAR_INIT(0);
atomic<int> ai1(0);

`atomic::operator Ty`

指定给模板的类型的运算符，atomic<Ty>。检索 *this 中的存储值。

atomic<Ty>::operator Ty() const volatile noexcept;
atomic<Ty>::operator Ty() const noexcept;

备注

此运算符应用 memory_order_seq_cst memory_order.

`atomic::operator=`

存储指定值。

Ty operator=(
   Ty Value
) volatile noexcept;
Ty operator=(
   Ty Value
) noexcept;

参数

Value
Ty 对象。

返回值

返回 Value。

`atomic::operator++`

增加存储值。仅由整型和指针专用化使用。

Ty atomic<Ty>::operator++(int) volatile noexcept;
Ty atomic<Ty>::operator++(int) noexcept;
Ty atomic<Ty>::operator++() volatile noexcept;
Ty atomic<Ty>::operator++() noexcept;

返回值

前两个运算符返回增加的值；最后两个运算符返回增量之前的值。运算符使用 memory_order_seq_cst memory_order.

`atomic::operator+=`

将指定的值添加到存储的值。仅由整型和指针专用化使用。

Ty atomic<Ty>::operator+=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator+=(
   Ty Value
) noexcept;

参数

Value
整数或指针值。

返回值

一个 Ty 对象，包含加法结果。

备注

此运算符使用 memory_order_seq_cst memory_order.

`atomic::operator--`

逐量减小存储值。仅由整型和指针专用化使用。

Ty atomic<Ty>::operator--(int) volatile noexcept;
Ty atomic<Ty>::operator--(int) noexcept;
Ty atomic<Ty>::operator--() volatile noexcept;
Ty atomic<Ty>::operator--() noexcept;

返回值

前两个运算符返回递减的值；最后两个运算符返回递减之前的值。运算符使用 memory_order_seq_cst memory_order.

`atomic::operator-=`

从存储的值减去指定的值。仅由整型和指针专用化使用。

Ty atomic<Ty>::operator-=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator-=(
   Ty Value
) noexcept;

参数

Value
整数或指针值。

返回值

包含减法结果的 Ty 对象。

注解

此运算符使用 memory_order_seq_cst memory_order.

`atomic::operator&=`

对 *this 的指定值和存储值执行按位“与”(&)。仅由整型专用化使用。

atomic<Ty>::operator&= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator&= (
   Ty Value
) noexcept;

参数

Value
一个 Ty 类型的值。

返回值

按位“与”(&) 的结果。

注解

此运算符执行读-修改-写操作，以将存储的值*this替换为按位“and”（&）Value以及存储在*this其中的当前值（在约束memory_order_seq_cstmemory_order范围内）。

`atomic::operator|=`

对 *this 的指定值和存储值执行按位“或”(|)。仅由整型专用化使用。

atomic<Ty>::operator|= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator|= (
   Ty Value
) noexcept;

参数

Value
一个 Ty 类型的值。

返回值

按位“或”(|) 的结果。

注解

此运算符执行读取-修改-写入操作，以将存储的值*this替换为约束中memory_order_seq_cst*thismemory_order存储的Value按位“或”（|或）和当前值。

`atomic::operator^=`

对 *this 的指定值和存储值执行按位“异或”(^)。仅由整型专用化使用。

atomic<Ty>::operator^= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator^= (
   Ty Value
) noexcept;

参数

Value
一个 Ty 类型的值。

返回值

按位“异或”(^) 的结果。

备注

此运算符执行读取-修改-写入操作，以将存储的值*this替换为约束中memory_order_seq_cst*thismemory_order存储的Value按位“排他或”（^）和当前值。

`atomic::compare_exchange_strong`

对 *this 执行原子比较和交换操作。

bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

参数

Exp
一个 Ty 类型的值。

Value
一个 Ty 类型的值。

Order1
第一个 memory_order 参数。

Order2
第二个 memory_order 参数。

返回值

指示值比较的结果的 bool。

备注

此原子比较和交换操作将存储在 *this 中的值与 Exp 进行比较。如果这些值相等，该操作会通过使用读取-写入-修改操作将存储在 *this 对象中的值替换为 Value，并应用 Order1 指定的内存顺序约束。如果值不相等，则操作使用存储在 *this 的值替换 Exp，然后应用由 Order2 指定的内存顺序约束。

如果重载没有另外一个 memory_order，则使用隐式 Order2，后者是基于 Order1 的值。如果 Order1 为 memory_order_acq_rel，则 Order2 为 memory_order_acquire。如果 Order1 为 memory_order_release，则 Order2 为 memory_order_relaxed。在所有其他情况下，Order2 等于 Order1。

对于采用两 memory_order 个参数的重载，Order2 的值不得为 memory_order_release 或 memory_order_acq_rel，且不得大于 Order1 的值。

`atomic::compare_exchange_weak`

对 *this 执行弱原子比较和交换操作。

bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

参数

Exp
一个 Ty 类型的值。

Value
一个 Ty 类型的值。

Order1
第一个 memory_order 参数。

Order2
第二个 memory_order 参数。

返回值

指示值比较的结果的 bool。

备注

如果所比较的值相等，一个弱原子比较和交换操作将执行交换。如果值不相等，则不能保证操作会执行交换。

对于采用两 memory_order 个参数的重载，Order2 的值不得为 memory_order_release 或 memory_order_acq_rel，且不得大于 Order1 的值。

`atomic::exchange`

使用指定值替换 *this 的存储值。

Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

交换前 *this 的存储值。

备注

此操作将在 Order 指定的内存约束中执行“读取-修改-写入”操作，以使用 Value 替换存储在 *this 中的值。

`atomic::fetch_add`

获取存储在 *this 中的值，然后将指定的值添加到存储的值。

Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

一个 Ty 对象，包含在相加之前 *this 中存储的值。

备注

fetch_add 方法执行读取-修改-写入操作以原子方式将 Value 与 *this 中的存储值相加，然后应用由 Order 指定的内存约束。

`atomic::fetch_and`

在某个值或存储在 *this 中的现有值执行按位“与”(&)。

Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

包含按位“与”（&）的结果的 Ty 对象。

备注

fetch_and 方法执行“读取-修改-写入”操作以将 *this 的存储值替换为 Value 的按位“与”(&)和存储在 *this 中的当前值（限于 Order 指定的内存约束）。

`atomic::fetch_or`

在某个值或存储在 *this 中的现有值执行按位“或”(|)。

Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

包含按位“或”（|）的结果的 Ty 对象。

备注

fetch_or 方法执行“读取-修改-写入”操作以将 *this 的存储值替换为 Value 的按位“或”(|)和存储在 *this 中的当前值（限于 Order 指定的内存约束）。

`atomic::fetch_sub`

从存储的值减去指定的值。

Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

包含减法结果的 Ty 对象。

备注

fetch_sub 方法执行读取-修改-写入操作，以在 Order 指定的内存约束范围内，以原子方式将 *this 中存储的值与 Value 相减。

`atomic::fetch_xor`

对某个值和存储在 *this 对象中的一个现有值执行按位“异或”(^)。

Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
一个 Ty 类型的值。

Order
一个 memory_order。

返回值

包含按位“异或”（^）的结果的 Ty 对象。

备注

fetch_xor 方法执行“读取-修改-写入”操作以将 *this 的存储值替换为 Value 的按位“异或”(^)和存储在 *this 中的当前值，并应用由 Order 指定的内存约束。

`atomic::is_lock_free`

指定 *this 上的atomic操作是否为无锁。

bool is_lock_free() const volatile noexcept;

返回值

如果对 *this 执行的atomic（原子）操作为无锁，则返回 true；否则，返回 false。

备注

如果对 atomic 类型的所有 atomic 操作都没有使用锁，则此类型为“无锁”。

`atomic::load`

在指定的内存约束内检索 *this 中存储的值。

Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const volatile noexcept;
Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const noexcept;

参数

Order
一个 memory_order。 Order 不得为 memory_order_release 和 memory_order_acq_rel。

返回值

存储在 *this 中的检索到的值。

`atomic::store`

存储指定值。

void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

参数

Value
Ty 对象。

Order
memory_order 约束。

备注

此成员函数在 Order 指定的内存约束内以原子方式将 Value 存储在 *this 中。

另请参阅

<atomic>
头文件引用

通过

atomic 结构

语法

成员

注解

要求

atomic::atomic

参数

注解

atomic::operator Ty

备注

atomic::operator=

参数

返回值

atomic::operator++

返回值

atomic::operator+=

参数

返回值

备注

atomic::operator--

返回值

atomic::operator-=

参数

返回值

注解

atomic::operator&=

参数

返回值

注解

atomic::operator|=

参数

返回值

注解

atomic::operator^=

参数

返回值

备注

atomic::compare_exchange_strong

参数

返回值

备注

atomic::compare_exchange_weak

参数

返回值

备注

atomic::exchange

参数

返回值

备注

atomic::fetch_add

参数

返回值

备注

atomic::fetch_and

参数

返回值

备注

atomic::fetch_or

参数

返回值

备注

atomic::fetch_sub

参数

返回值

备注

atomic::fetch_xor

参数

返回值

备注

atomic::is_lock_free

返回值

备注

atomic::load

参数

返回值

atomic::store

参数

备注

另请参阅

`atomic` 结构

`atomic::atomic`

`atomic::operator Ty`

`atomic::operator=`

`atomic::operator++`

`atomic::operator+=`

`atomic::operator--`

`atomic::operator-=`

`atomic::operator&=`

`atomic::operator|=`

`atomic::operator^=`

`atomic::compare_exchange_strong`

`atomic::compare_exchange_weak`

`atomic::exchange`

`atomic::fetch_add`

`atomic::fetch_and`

`atomic::fetch_or`

`atomic::fetch_sub`

`atomic::fetch_xor`

`atomic::is_lock_free`

`atomic::load`

`atomic::store`