赋值运算符

 

C++

语言

标准库头文件

自立与有宿主实现

具名要求

语言支持库

概念库 (C++20)

诊断库

工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

原子操作库 (C++11)

线程支持库 (C++11)

技术规范

 

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

默认比较(C++20)

运算符的代用表示

优先级和结合性

折叠表达式(C++17)

new 表达式

delete 表达式

throw 表达式

alignof

sizeof

sizeof...(C++11)

typeid

noexcept(C++11)

运算符重载

类型转换

隐式转换

const_cast

static_cast

reinterpret_cast

dynamic_cast

显式转换 (T)a, T(a)

用户定义转换

 

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

运算符名	语法	可重载	原型示例（对于 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& 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 起)

(C++11 起)

对于非类类型，对复制与移动赋值不加以区分，均被称作直接赋值（direct assignment）。

复合赋值（compound assignment）运算符以 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() 内来看，+= 要么完全未开始，要么已完成）。

以 volatile 限定的非类类型左值为内建复合赋值运算符的左操作数被弃用。

(C++20 起)

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

参阅

运算符优先级

运算符重载

常见运算符
赋值	自增 自减	算术	逻辑	比较	成员访问	其他
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 ? :
特殊运算符
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 起)