赋值运算符

来自cppreference.com
< cpp‎ | language
 
C++
 
C++ 语言
 
表达式
概述
值类别（左值 lvalue、右值 rvalue、亡值 xvalue）
求值顺序（序列点）
常量表达式
潜在求值表达式
初等表达式
lambda 表达式(C++11)
字面量
整数字面量
浮点字面量
布尔字面量
字符字面量，包含转义序列
字符串字面量
空指针字面量(C++11)
用户定义字面量(C++11)
运算符
赋值运算符： 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||b，a&&b，!a
比较运算符：a==b，a!=b，a<b，a>b，a<=b，a>=b，a<=>b(C++20)
成员访问运算符：a[b]，*a，&a，a->b，a.b，a->*b，a.*b
其他运算符：a(...)，a,b，a?b:c
new 表达式
delete 表达式
throw 表达式
alignof
sizeof
sizeof...(C++11)
typeid
noexcept(C++11)
折叠表达式(C++17)
运算符的代用表示
优先级和结合性
运算符重载
默认比较(C++20)
类型转换
隐式转换
一般算术转换
const_cast
static_cast
reinterpret_cast
dynamic_cast
显式转换 (T)a, T(a)
用户定义转换
 

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

运算符名 语法 可重载 原型示例（对于 class T）
类内定义 类外定义
简单赋值 a = b 是 T& T::operator =(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& 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);
注意
  • 所有内建赋值运算符都返回 *this，而大多数用户定义重载也会返回 *this，从而能以与内建版本相同的方式使用用户定义运算符。然而，用户定义运算符重载中，返回类型可以是任意类型（包括 void）。
  • T2 可以是包含 T 在内的任意类型

解释

复制赋值运算符以 b 内容的副本替换对象 a 的内容（不修改 b）。对于类类型，这是一种特殊成员函数，描述见复制赋值运算符。

移动赋值运算符以 b 的内容替换对象 a 的内容，并尽可能避免复制（可以修改 b）。对于类类型，这是一种特殊成员函数，描述见移动赋值运算符。

(C++11 起)

对于非类类型，对复制与移动赋值不加以区分，它们都被称作直接赋值。

复合赋值运算符以 a 的值和 b 的值间的二元运算结果替换对象 a 的内容。

内建的直接赋值

直接赋值表达式的形式为

左操作数 = 右操作数 (1)
左操作数 = {} (2) (C++11 起)
左操作数 = { 右操作数 } (3) (C++11 起)

对于内建运算符，左操作数 可以拥有任何非 const 标量类型，而 右操作数 必须能隐式转换到 左操作数 的类型。

直接赋值运算符期待以一个可修改左值作为它的左操作数，以一个右值表达式或花括号初始化器列表 (C++11 起)作为它的右操作数，并返回一个标识修改后的左操作数的左值。如果左操作数是位域，那么返回结果也是位域。

对于非类类型，首先将右操作数隐式转换到左操作数的无 cv 限定的类型，然后复制它的值到左操作数所标识的对象中。

当左操作数拥有引用类型时，赋值运算符修改被引用的对象。

如果左右操作数标识的对象之间有重叠，那么行为未定义（除非二者严格重叠且类型相同）。

当右运算数是花括号初始化器列表 (brace-init-list)时

  • 如果表达式 E1 拥有标量类型，那么
  • 表达式 E1 = {} 与 E1 = T{} 等价，其中 T 是 E1 的类型。
  • 表达式 E1 = {E2} 与 E1 = T{E2} 等价，其中 T 是 E1 的类型。
  • 如果表达式 E1 拥有类类型，那么语法 E1 = {args...} 会生成以花括号初始化器列表为实参对赋值运算符的一次调用，然后遵循重载决议规则选取适合的赋值运算符。需要注意的是，如果以某个非类类型为实参的非模板赋值运算符可用，那么它胜过 E1 = {} 中的复制/移动赋值，这是因为从 {} 到非类类型属于恒等转换，它优先于从 {} 到类类型的用户定义转换。
(C++11 起)

以 volatile 限定的非类类型左值为内建直接赋值运算符的左操作数被弃用，除非该赋值表达式在不求值语境或是弃值表达式中出现。

(C++20 起)

针对用户定义运算符的重载决议中，对于每个类型 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);

示例

运行此代码
#include <iostream>
 
int main()
{
    int n = 0;        // 不是赋值
 
    n = 1;            // 直接赋值
    std::cout << n << ' ';
 
    n = {};           // 零初始化，然后赋值
    std::cout << n << ' ';
 
    n = 'a';          // 整型提升，然后赋值
    std::cout << n << ' ';
 
    n = {'b'};        // 显式转型，然后赋值
    std::cout << n << ' ';
 
    n = 1.0;          // 浮点转换，然后赋值
    std::cout << n << ' ';
 
//  n = {1.0};        // 编译错误（窄化转换）
 
    int& r = n;       // 不是赋值
    int* p;
 
    r = 2;            // 通过引用赋值
    std::cout << n << '\n';
 
    p = &n;           // 直接赋值
    p = nullptr;      // 空指针转换，然后赋值
 
    struct { int a; std::string s; } obj;
    obj = {1, "abc"}; // 从花括号初始化器列表赋值
    std::cout << obj.a << ':' << obj.s << '\n';
}

输出： 

1 0 97 98 1 2
1:abc

内建的复合赋值

复合赋值表达式的形式为

左操作数 运算符 右操作数 (1)
左操作数 运算符 {} (2) (C++11 起)
左操作数 运算符 { 右操作数 } (3) (C++11 起)
运算符 - *=、/=、%=、+=、-=、<<=、>>=、&=、^=、|= 之一
左操作数 - 对于内建运算符，左操作数 可具有任何算术类型，但如果 运算符 是 += 或 -=，那么它也接受指针类型，并与 + 和 - 有相同限制
右操作数 - 对于内建运算符，右操作数 必须可隐式转换成 左操作数

每个内建复合赋值运算符表达式 E1 op= E2（其中 E1 是可修改左值表达式，而 E2 是右值表达式或花括号初始化器列表 (C++11 起)）的行为与表达式 E1 = E1 op E2 的行为严格相同，但只对表达式 E1 进行一次求值，并且对于顺序不确定的函数而言是一次单个操作（例如 f(a += b, g()) 中，从 g() 内来看，+= 要么完全未开始，要么已完成）。

在针对用户定义运算符的重载决议中，对每对 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);

示例

本节未完成
原因：暂无示例

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
CWG 1527 C++11 只有在赋值由用户定义的赋值运算符定义的情况下才能将初始化列表赋给类类型对象 移除用户定义赋值限制
CWG 1538 C++11 E1 = {E2} 曾与 E1 = T(E2)（T 是 E1 的类型）等价，这会引入 C 风格转型 现在与 E1 = T{E2} 等价
P2327R1 C++20 volatile 类型的逐位复合赋值运算符对一些平台有用但被弃用 不弃用它们
CWG 2654 C++20 volatile 类型的复合赋值运算符被以不一致的方式弃用 它们均不被弃用

参阅

运算符优先级

运算符重载

常见运算符
赋值 自增/自减 算术 逻辑 比较 成员访问 其他

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[b]
*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 起)

来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/language/operator_assignment&oldid=75665”