命名空间
变体
操作

赋值运算符

来自 cppreference.com
< cpp‎ | 语言
 
C++
 
C++ 语言
 
表达式
一般
字面量
运算符
转换
 

赋值运算符修改对象的值。

运算符名称  语法  可重载 原型示例（对于 class T）
在类定义内部 在类定义外部
简单赋值 a = b 是 T& T::operator =(const T2& b); N/A
加法赋值 a += b 是 T& T::operator +=(const T2& b); T& operator +=(T& a, const T2& b);
减法赋值 a -= b 是 T& T::operator -=(const T2& b); T& operator -=(T& a, const T2& b);
乘法赋值 a *= b 是 T& T::operator *=(const T2& b); T& operator *=(T& a, const T2& b);
除法赋值 a /= b 是 T& T::operator /=(const T2& b); T& operator /=(T& a, const T2& b);
取模赋值 a %= b 是 T& T::operator %=(const T2& b); T& operator %=(T& a, const T2& b);
按位与赋值 a &= b 是 T& T::operator &=(const T2& b); T& operator &=(T& a, const T2& b);
按位或赋值 a |= b 是 T& T::operator |=(const T2& b); T& 运算符 |=(T& a, const T2& b);
按位异或赋值 a ^= b 是 T& T::operator ^=(const T2& b); T& 运算符 ^=(T& a, const T2& b);
按位左移赋值 a <<= b 是 T& T::operator <<=(const T2& b); T& 运算符 <<=(T& a, const T2& b);
按位右移赋值 a >>= b 是 T& T::operator >>=(const T2& b); T& 运算符 >>=(T& a, const T2& b);
注意
  • 所有内置的赋值运算符都返回 *this，大多数 用户定义的重载 也返回 *this，以便用户定义的运算符可以像内置运算符一样使用。但是，在用户定义的运算符重载中，任何类型都可以用作返回值类型（包括 void）。
  • T2 可以是任何类型，包括 T。

内容

[编辑] 定义

复制赋值 将对象 a 的内容替换为 b 的内容副本（b 不修改）。对于类类型，这在特殊成员函数中执行，如 复制赋值运算符 中所述。

移动赋值 将对象 a 的内容替换为 b 的内容，尽可能避免复制（b 可能会被修改）。对于类类型，这在特殊成员函数中执行，如 移动赋值运算符 中所述。

 (自 C++11 起)

对于非类类型，复制和移动赋值是不可区分的，统称为直接赋值。

复合赋值 将对象 a 的内容替换为 a 的先前值和 b 的值之间的二元运算结果。

[编辑] 赋值运算符语法

赋值表达式具有以下形式

目标表达式 = 新值 (1)
目标表达式 运算符 新值 (2)
目标表达式 - 要赋予的表达式[1]
运算符 - *=、/= %=、+= -=、<<=、>>=、&=、^=、|= 之一
新值 - 要赋予目标的表达式[2](直到 C++11)初始化子句(自 C++11 起)
  1. ↑ 目标表达式 必须比赋值表达式具有更高的 优先级。
  2. ↑ 新值 不能是逗号表达式，因为它的 优先级 更低。
1) 简单赋值表达式。
2) 复合赋值表达式。

如果 新值 不是表达式，则赋值表达式将永远不会匹配重载的复合赋值运算符。

 (自 C++11 起)

[编辑] 内置简单赋值运算符

对于内置的简单赋值，由 目标表达式 引用的对象通过用 新值 的结果替换其值来修改。 目标表达式 必须是可修改的左值。

内置简单赋值的结果是 目标表达式 类型的左值，引用 目标表达式。如果 目标表达式 是一个 位域，则结果也是一个位域。

[编辑] 从表达式赋值

如果 新值 是一个表达式，它将 隐式转换为 目标表达式 的 cv 无限定类型。当 目标表达式 是一个不能表示表达式值的位域时，位域的最终值是实现定义的。

如果 目标表达式 和 新值 标识重叠的对象，则行为未定义（除非重叠是精确的，并且类型相同）。

如果 目标表达式 的类型是 volatile 限定的，则赋值会被弃用，除非（可能带括号的）赋值表达式是 丢弃值表达式 或 未计算的操作数。

 (自 C++20 起)


从非表达式初始化子句赋值

新值 只允许在以下情况下不是表达式

  • 目标表达式 是 标量类型 T，新值 为空或只有一个元素。在这种情况下，给定一个声明并初始化为 T t = 新值  的虚构变量 t，x = 新值  的含义是 x = t.
  • 目标表达式 是类类型。在这种情况下，新值 被传递为由 重载解析 选择的赋值运算符函数的参数。
#include <complex>
 
std::complex<double> z;
z = {1, 2};  // meaning z.operator=({1, 2})
z += {1, 2}; // meaning z.operator+=({1, 2})
 
int a, b;
a = b = {1}; // meaning a = b = 1;
a = {1} = b; // syntax error
 (自 C++11 起)

在 针对用户定义运算符的重载解析 中，对于每种类型 T，以下函数签名参与重载解析

T*& operator=(T*&, T*);
T*volatile & operator=(T*volatile &, T*);

对于每种枚举或指向成员类型的 T，可选地进行 volatile 限定，以下函数签名参与重载解析

T& operator=(T&, T);

对于每一对 A1 和 A2，其中 A1 是算术类型（可选地进行 volatile 限定），A2 是提升的算术类型，以下函数签名参与重载解析

A1& operator=(A1&, A2);

[编辑] 内置复合赋值运算符

每个内置的复合赋值表达式 目标表达式 运算符 = 新值 的行为与表达式 目标表达式 = 目标表达式 运算符 新值 的行为完全相同，只是 目标表达式 只被计算一次。

内置简单赋值运算符对 目标表达式 和 新值 的要求也适用。此外

  • 对于 += 和 -=，目标表达式 的类型必须是 算术类型 或指向（可能 cv 限定的）完全定义的 对象类型 的指针。
  • 对于所有其他复合赋值运算符，目标表达式 的类型必须是算术类型。

在针对用户定义运算符的重载解析中，对于每对A1和A2，其中A1是算术类型（可选地带volatile限定符）并且A2是提升后的算术类型，以下函数签名参与重载解析

A1& operator*=(A1&, A2);
A1& operator/=(A1&, A2);
A1& operator+=(A1&, A2);
A1& operator-=(A1&, A2);

对于每对I1和I2，其中I1是整型（可选地带volatile限定符）并且I2是提升后的整型，以下函数签名参与重载解析

I1& operator%=(I1&, I2);
I1& operator<<=(I1&, I2);
I1& operator>>=(I1&, I2);
I1& operator&=(I1&, I2);
I1& operator^=(I1&, I2);
I1& operator|=(I1&, I2);

对于每个可选地带cv限定符的对象类型T，以下函数签名参与重载解析

T*& operator+=(T*&, std::ptrdiff_t);
T*& operator-=(T*&, std::ptrdiff_t);
T*volatile & operator+=(T*volatile &, std::ptrdiff_t);
T*volatile & operator-=(T*volatile &, std::ptrdiff_t);

[edit] Example

运行此代码
#include <iostream>
 
int main()
{
    int n = 0;        // not an assignment
 
    n = 1;            // direct assignment
    std::cout << n << ' ';
 
    n = {};           // zero-initialization, then assignment
    std::cout << n << ' ';
 
    n = 'a';          // integral promotion, then assignment
    std::cout << n << ' ';
 
    n = {'b'};        // explicit cast, then assignment
    std::cout << n << ' ';
 
    n = 1.0;          // floating-point conversion, then assignment
    std::cout << n << ' ';
 
//  n = {1.0};        // compiler error (narrowing conversion)
 
    int& r = n;       // not an assignment
    r = 2;            // assignment through reference
    std::cout << n << ' ';
 
    int* p;
    p = &n;           // direct assignment
    p = nullptr;      // null-pointer conversion, then assignment
    std::cout << p << ' ';
 
    struct { int a; std::string s; } obj;
    obj = {1, "abc"}; // assignment from a braced-init-list
    std::cout << obj.a << ':' << obj.s << '\n';
}

可能的输出

1 0 97 98 1 2 (nil) 1:abc

[edit] 缺陷报告

以下行为更改缺陷报告被追溯应用于先前发布的 C++ 标准。

DR 应用于 已发布的行为 正确行为
CWG 1527 C++11 对于类类型对象的赋值，右操作数
只能在赋值
由用户定义的赋值运算符定义时为初始化列表		 删除用户定义的
赋值约束
CWG 1538 C++11 E1 = {E2} 等效于 E1 = T(E2)
(T 是 E1 的类型)，这引入了 C 风格的强制类型转换		 它等效于
E1 = T{E2}
CWG 2654 C++20 用于 volatile
限定类型的复合赋值运算符不一致地被弃用		 它们中的任何一个
都不会被弃用
CWG 2768 C++11 从非表达式初始化子句
到标量值的赋值将执行直接列表初始化		 而是执行复制列表
初始化
P2327R1 C++20 用于 volatile 类型的按位复合赋值运算符
被弃用，而它们对于某些平台很有用		 它们不会被
弃用

[edit] 另请参见

运算符优先级

运算符重载

常用运算符
赋值 递增
递减 		算术 逻辑 比较 成员
访问 		其他

a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b

a[...]
*a
&a
a->b
a.b
a->*b
a.*b

函数调用
a(...)
逗号
a, b
条件
a ? b : c
特殊运算符

static_cast 将一种类型转换为另一种相关类型
dynamic_cast 在继承层次结构中进行转换
const_cast 添加或删除cv 限定符
reinterpret_cast 将类型转换为无关类型
C 风格的强制类型转换 通过混合使用 static_cast、const_cast 和 reinterpret_cast 将一种类型转换为另一种类型
new 创建具有动态存储期的对象
delete 销毁先前由 new 表达式创建的对象并释放获得的内存区域
sizeof 查询类型的尺寸
sizeof... 查询参数包 的尺寸(自 C++11 起)
typeid 查询类型的类型信息
noexcept 检查表达式是否可以抛出异常(自 C++11 起)
alignof 查询类型的对齐要求(自 C++11 起)

C 文档 针对 赋值运算符
检索自 "https://cppreference.cn/mwiki/index.php?title=cpp/language/operator_assignment&oldid=169197"