C++ 表达式怎么读:从一行代码到类型、值类别和生命周期
写在前面
先看一行代码:
cpp
int a[10];
int* p = a;
int* q = a + 1;
*p++ = *q++;
这一行里藏着好几个问题:
*p++到底是(*p)++还是*(p++)?p++和*p分别是什么类型、什么值类别?- 赋值的左边和右边,谁先算?
p和q什么时候加一?- 如果
p和q指向同一块内存,结果还一样吗?
上一篇《C++ 左值与右值》列过一张表达式值类别的表。很多人看完表,遇到新的表达式还是会判断错。问题通常不在看过多少遍,而在于没有一套固定的拆解顺序:先看什么、后看什么、看到什么就该得出什么结论。
这篇文章想解决的就是这件事。它不要求你背一张大表,而是给你一套可以重复使用的方法。读完以后,遇到一个没见过的表达式,你至少知道从哪儿下手。
整套方法可以压缩成四个问题:
- 这棵表达式树长什么样? 谁和谁先结合?
- 每个节点的类型是什么? 这决定了能做哪些运算、会发生哪些转换。
- 每个节点的值类别是什么? 这决定了能绑定什么引用、会不会被移动。
- 有没有副作用?谁先谁后?临时对象活多久?
下面按这四问展开。
目录
- 第一部分 先把表达式看成一棵树
*- 表达式是什么
-
- 表达式和语句不是一回事
-
- 优先级和结合性:树怎么长
-
- 读表达式的四问法
-
- 一个完整的拆解示例
- 第二部分 一类一类认识表达式
-
- 名字
-
- 字面量
-
- 一元表达式
-
- 二元表达式
-
- 成员访问
-
- 下标
-
- 函数调用
-
- 条件表达式
-
- 逗号表达式
-
- 赋值表达式
-
- 强制转换
-
- sizeof、alignof、decltype、typeid、noexcept
-
- new、delete、throw
-
- lambda 表达式
-
- C++17/20/23 的新表达式
-
- 第三部分 类型、值类别、转换和求值
-
- 类型怎么定
-
- 值类别怎么定
-
- 隐式转换
-
- 重载决议
-
- 临时对象和生命周期
-
- 求值顺序和副作用
-
- 重载运算符和代理对象
-
- 表达式模板和惰性求值
-
- 第四部分 上一篇文章里的表达式逐个拆
-
- 速查表
-
- 容易看错的十几个表达式
-
- 一套通用的拆解流程
-
- 二十个容易误判的案例
-
- 怎么练习,靠方法
-
- 练习题
-
- 参考资料
-
第一部分 先把表达式看成一棵树
1. 表达式是什么
C++ 标准给表达式的定义很朴素:表达式是运算符和操作数的序列,它指定一项计算。
cpp
2 + 2 // 表达式,结果是 4
x // 表达式,表示一个对象
f(1, 2) // 表达式,调用函数
x = 1 // 表达式,赋值
std::move(x) // 表达式,函数调用
表达式求值可能产生一个结果,也可能产生副作用。2 + 2 只产生结果;x = 1 既产生结果(赋值表达式的结果是左操作数),又修改了 x;std::printf("hi") 的副作用是往标准输出写字符,返回值是写入的字符数。
每个 C++ 表达式都有两个独立的属性:
- 类型:这个表达式算出来的东西是什么类型。
- 值类别:这个表达式代表一个对象,还是一个值;这个对象能不能被搬走。
值类别分三种基本类型:
- lvalue(左值):有身份,通常有地址,不能被随便搬走。
- xvalue(将亡值):有身份,但资源可以被搬走。
- prvalue(纯右值):没有身份,是一个临时的值。
这两个属性要分开看。比如:
cpp
std::string s = "hello";
std::string&& r = std::move(s);
r 的声明类型是 std::string&&,但表达式 r 的值类别是左值。这里还有一个标准细节:表达式的类型会去掉引用,所以 r 的表达式类型是 std::string,不是 std::string&&。引用信息体现在值类别上。
后面为了跟日常说法衔接,有时会说"函数返回 T&&"或者"std::move(x) 的类型是 T&&",那说的是返回类型或声明类型。严格说,调用表达式的类型是去掉引用后的 T。这个区别不影响大多数日常讨论,但在读 decltype、重载决议和模板推导时会很重要。
2. 表达式和语句不是一回事
初学者容易把"一行代码"都叫表达式,其实 C++ 里至少有三种东西:
- 表达式 :
x + 1、f()、x = 1。 - 语句 :
if (x) ...、for (...) ...、return x;、x = 1;(表达式语句)。 - 声明 :
int x;、void f();、using T = int;。声明也可以出现在语句位置,比如int x = 1;,但它首先是声明。
区分它们有用,因为很多规则只对表达式生效。
cpp
int x = 1; // 这是声明,不是表达式
x = 1; // 这是表达式语句,核心是赋值表达式
return x; // 这是 return 语句,x 是其中的表达式
一个常见的坑是"最令人烦恼的解析"(most vexing parse):
cpp
T x(); // 这是函数声明,不是变量定义
T x{}; // 这是变量定义(C++11 起)
T x; // 这是变量定义
T x(); 看起来像一个用默认构造函数创建的变量,但 C++ 的语法规则要求把它解释成"函数 x,返回 T,不接受参数"。想定义一个变量,用 T x; 或 T x{};。
3. 优先级和结合性:树怎么长
表达式不是从左往右平铺计算的,它先被解析成一棵树。决定树形的有两个规则:
- 优先级:哪个运算符先和操作数结合。
- 结合性:同一优先级的运算符,从左往右还是从右往左结合。
1 + 2 * 3 的树是:
text
+
/ \
1 *
/ \
2 3
乘法优先级高,所以先结合 2 * 3,再和 1 相加。
下面是一张简化过的优先级表,从高到低:
| 优先级 | 运算符 | 结合性 |
|-----|--------------------------------------------------------------------------|---------------------------|----|---|
| 1 | :: | 左 |
| 2 | a++、a--、a()、a[]、a.b、a->b | 左 |
| 3 | ++a、--a、+a、-a、!a、~a、*a、&a、(T)a、sizeof、new、delete | 右 |
| 4 | .*、->* | 左 |
| 5 | *、/、% | 左 |
| 6 | +、- | 左 |
| 7 | <<、>> | 左 |
| 8 | <=> | 左 |
| 9 | <、<=、>、>= | 左 |
| 10 | ==、!= | 左 |
| 11 | &(按位与) | 左 |
| 12 | ^ | 左 |
| 13 | ` | ` | 左 |
| 14 | && | 左 |
| 15 | ` | | ` | 左 |
| 16 | ?: | 右 |
| 17 | =、+=、-=、*=、/=、%=、&=、` | =、^=、<<=、>>=` | 右 |
| 18 | , | 左 |
这张表不用背。写代码时,拿不准就加括号。读代码时,先找优先级最低的运算符,它通常是整棵树的根。
几个常见例子:
cpp
*p++ // *(p++):后置 ++ 比一元 * 优先级高
++*p // ++(*p):一元 * 和前缀 ++ 结合,先解引用再自增
*++p // *(++p):先自增指针,再解引用
a = b = c // a = (b = c):赋值右结合
a - b - c // (a - b) - c:减法左结合
a ? b : c ? d : e // a ? b : (c ? d : e):条件运算符右结合
括号能改变树形,也能让代码更容易读:
cpp
*p++ // 等价于 *(p++)
(*p)++ // 先解引用,再把指向的值加一
这两个表达式只差一对括号,意思完全不同。
4. 读表达式的四问法
遇到一个表达式,按下面四步走。
第一问:树长什么样
先找最外层的运算符。它通常是优先级最低的那个。
cpp
a + b * c // 根是 +,右子树是 b * c
a = b + c // 根是 =,右边是 b + c
*p++ // 根是一元 *,操作数是 p++
a ? b : c // 根是 ?:,三个操作数分别是 a、b、c
如果表达式里有逗号、赋值、条件运算符,特别要小心,它们的优先级低,容易把整棵树的结构看错。
第二问:每个节点是什么类型
从叶子往根推。叶子通常是变量、字面量、函数调用。每个运算符根据自己的规则,决定结果类型。
cpp
int x = 1;
double y = 2.0;
x + 1 // int + int -> int
x + y // int + double -> double(usual arithmetic conversions)
&x // int*
*p // int&(p 是 int*)
类型决定了:
- 能做哪些运算。
- 会发生哪些隐式转换。
- 函数重载选哪一个。
sizeof是多少。
第三问:每个节点是什么值类别
值类别只有三种基本类型:
- lvalue(左值):有身份,通常有地址,不能被随便搬走。
- xvalue(将亡值):有身份,但资源可以被搬走。
- prvalue(纯右值):没有身份,是一个临时的值。
判断时,先看这个表达式属于哪一类,再看操作数。
cpp
x // lvalue:有名字的变量
42 // prvalue:字面量
x + 1 // prvalue:运算结果
*p // lvalue:解引用
&x // prvalue:地址值
std::move(x) // xvalue:转成了右值
第四问:副作用、求值顺序、生命周期
前三个问题只回答"它是什么"。第四个问题回答"它做了什么,什么时候做,做完之后什么东西会消失"。
cpp
i = i++ // 有没有修改 i?谁先谁后?
f(i++, i++) // 两个参数谁先算?
const int& r = std::max(1, 2); // r 绑定到了什么?能活多久?
x = std::move(y) // y 之后还能用吗?
这一问最容易出 bug,因为编译器在某些地方允许不同的求值顺序,而临时对象的生命周期又常常比你想的短。
5. 一个完整的拆解示例
回到开头那行:
cpp
*p++ = *q++;
第一步:拆树
后置 ++ 的优先级高于一元 *,赋值的优先级最低。所以这行代码等价于:
cpp
*(p++) = *(q++);
树形大致是:
text
=
/ \
* *
/ \
p++ q++
第二步:看类型
假设 p 和 q 都是 int*,指向 int 数组。
p:int*,lvalue。p++:int*,prvalue,返回自增前的指针值。*(p++):int,lvalue,指向自增前p所指的那个int。(表达式类型去掉了引用,int&是它的引用类型。)q++:int*,prvalue。*(q++):int,lvalue。- 整个赋值表达式:
int,lvalue,指向左边那个int。
第三步:看值类别
p++、q++是 prvalue。*(p++)、*(q++)是 lvalue。- 赋值表达式本身是 lvalue。
第四步:看副作用和顺序
p++会修改p,让它指向下一个元素。q++会修改q。- 赋值会修改
*(p++)指向的那个int。
C++17 起,赋值的右操作数先于左操作数求值。所以 *(q++) 先算完,*(p++) 后算。两边互不影响时,这个顺序无关紧要。如果 p 和 q 可能指向同一个对象,C++17 之前读和写无序,属于未定义行为;C++17 起有确定顺序,但代码仍然不容易读。
这行代码可以拆成更清楚的三行:
cpp
*p = *q;
++p;
++q;
效果通常一样,但读起来更直接。
这个例子说明什么
表达式的"意思"不是一眼看出来的,它由四个层面共同决定:怎么结合、什么类型、什么值类别、有什么副作用。只盯着运算符看,很容易判断错。
第二部分 一类一类认识表达式
6. 名字
最简单的表达式是一个名字:
cpp
x
std::cout
f
S::count
名字可以指很多东西:变量、函数、枚举项、类型、命名空间、模板。只有在表达式里出现的名字,才需要考虑类型和值类别。
6.1 变量名
cpp
int x = 1;
std::string s = "hello";
x 和 s 都是 lvalue。表达式类型是声明类型去掉引用;如果声明类型是 int&&,表达式类型是 int,值类别仍然是 lvalue。
即使变量的类型是右值引用,名字表达式仍然是左值:
cpp
int&& r = 42;
r // lvalue,不是 xvalue
原因很直接:r 有名字,有地址,在表达式里是一个普通对象。它的声明类型 int&& 只说明它当初绑定到了一个右值;表达式 r 的类型是 int,值类别是 lvalue。
6.2 函数名
cpp
void f();
auto p = &f; // p 的类型是 void(*)()
函数名本身是 lvalue,但在大多数表达式里会转换成函数指针(function-to-pointer conversion)。&f 和 f 在取地址时通常得到同一个函数指针。
6.3 枚举项
cpp
enum Color { Red, Green };
Color c = Red;
枚举项 Red 是 prvalue,不是 lvalue。它没有独立的对象身份,值就是常量本身。
6.4 限定名
cpp
std::cout
S::count
限定名只是名字的一种写法。std::cout 指标准库的全局对象,是 lvalue;S::count 如果是静态数据成员,是 lvalue;如果是枚举项,是 prvalue。
6.5 名字的 ODR 使用
名字出现在不需要它的定义的上下文里,可能不会产生真正的"使用"。比如:
cpp
extern int x;
sizeof(x); // 不需要 x 的定义
sizeof 的操作数不求值,所以 x 只需要声明,不需要定义。这类细节在做模板和条件编译时会遇到,平时写业务代码不用太紧张。
7. 字面量
字面量是直接写在源代码里的常量。
cpp
42
3.14
'a'
"hello"
true
nullptr
7.1 整数和浮点字面量
cpp
42 // int
42u // unsigned int
42L // long
42UL // unsigned long
42LL // long long
42.0 // double
42.0f // float
42.0L // long double
0x2A // 十六进制,int
052 // 八进制,int
0b101010 // 二进制,int(C++14)
1'000'000 // 数字分隔符(C++14)
这些字面量都是 prvalue。
7.2 字符和字符串字面量
cpp
'a' // char
L'a' // wchar_t
u'a' // char16_t
U'a' // char32_t
"hello" // const char[6]
L"hello" // const wchar_t[6]
u8"hello" // const char8_t[6](C++20)
R"(hello)" // 原始字符串字面量
这里有一个常被忽略的点:字符串字面量是 lvalue ,不是 prvalue。它的类型是 const char[N],存放在静态存储区,有固定地址,生命周期贯穿整个程序。
cpp
const char* p = "hello"; // "hello" 先退化成 const char*,再赋给 p
普通字面量(整数、浮点、字符、布尔、nullptr)是 prvalue;字符串字面量是 lvalue。这一条经常被"字面量都是右值"这种简化说法漏掉。
7.3 布尔和指针字面量
cpp
true // bool,prvalue
false // bool,prvalue
nullptr // std::nullptr_t,prvalue
nullptr 的类型是 std::nullptr_t,可以隐式转换成任意指针类型和成员指针类型。
NULL 通常是宏,展开后可能是 0 或 0L。它没有指针类型,在模板推导和重载决议里容易被当成整数。需要空指针时用 nullptr。
7.4 用户定义字面量
cpp
42_km // 可能是一个长度类型
"hello"s // std::string
用户定义字面量本质上是一个函数调用,类型由字面量运算符决定。它通常返回 prvalue,但也可以返回引用。
8. 一元表达式
一元表达式只有一个操作数。
cpp
+x
-x
!x
~x
*p
&x
++x
x++
--x
x--
sizeof(x)
alignof(T)
new T
delete p
8.1 算术和逻辑一元运算
cpp
+x // prvalue,通常发生 integral promotion
-x // prvalue
!x // prvalue,bool
~x // prvalue,按位取反
这些运算符都要求操作数能转换成算术类型或 bool。!x 会做上下文转换到 bool,~x 只适用于整数。
8.2 解引用
cpp
int x = 1;
int* p = &x;
*p = 2; // *p 是 lvalue
int y = *p; // 读取 *p 的值
内置 * 的结果是 lvalue,前提是 p 指向一个对象或函数。如果 p 是空指针、野指针,或者指向已经释放的内存,*p 的行为未定义。
8.3 取地址
cpp
int x = 1;
int* p = &x; // &x 是 prvalue,类型 int*
& 要求操作数是一个 lvalue(或者一个 qualified-id,用来取成员指针)。你不能对字面量、临时对象、位域取地址:
cpp
// int* p = &42; // 错误
// int* p = &(x + 1); // 错误
& 也可以被重载。重载之后,&x 可能不再是"取地址",而是调用 operator&。这很少见,但读老代码时要留意。
8.4 前置和后置自增
cpp
int x = 1;
++x; // lvalue,返回 x 本身
x++; // prvalue,返回旧值
++x:先把x加一,再返回x的引用。表达式是 lvalue。x++:先保存旧值,把x加一,再返回旧值。表达式是 prvalue。
重载之后,返回类型决定值类别:
cpp
struct S {
S& operator++(); // 前置,通常返回 S&
S operator++(int); // 后置,通常返回 S
};
8.5 sizeof 和 alignof
cpp
sizeof(int) // prvalue,std::size_t
sizeof x // prvalue
alignof(int) // prvalue,std::size_t
sizeof 的操作数不求值。sizeof(x++) 不会让 x 加一。
cpp
int x = 1;
std::size_t n = sizeof(x++); // x 仍然是 1
sizeof 一个数组得到整个数组的字节数;sizeof 一个指针得到指针本身的大小。数组作为函数参数时会退化成指针,所以在函数里 sizeof(arr) 通常不是你以为的数组大小。
9. 二元表达式
二元表达式有两个操作数。
cpp
a + b
a - b
a * b
a / b
a % b
a < b
a == b
a && b
a || b
a & b
a | b
a ^ b
a << b
a >> b
a = b
a += b
a, b
9.1 算术运算
cpp
int x = 1;
double y = 2.0;
x + y // double,prvalue
x * 2 // int,prvalue
x / 2 // int,整数除法
x % 2 // int,取余
算术运算符的结果都是 prvalue。两个操作数类型不同时,会发生 usual arithmetic conversions,把它们转换成共同的类型。
整数除以零是未定义行为;浮点除以零在支持 IEEE 754 的实现上得到无穷大或 NaN,否则行为由实现决定。
9.2 比较和逻辑运算
cpp
x < y // bool,prvalue
x == y // bool,prvalue
x && y // bool,prvalue
x || y // bool,prvalue
&& 和 || 有短路求值:
cpp
if (p != nullptr && p->value > 0) {
// 左边为 false 时,右边不会执行
}
短路是内置运算符的规则。重载 operator&& 和 operator|| 之后,它们变成函数调用,两个操作数都会求值,短路消失。这一点后面会细讲。
9.3 位运算和移位
cpp
x & y // 按位与,prvalue
x | y // 按位或,prvalue
x ^ y // 按位异或,prvalue
x << 1 // 左移,prvalue
x >> 1 // 右移,prvalue
移位要求操作数是整数。移位次数为负,或者大于等于操作数的位宽,行为未定义。
<< 和 >> 也经常被重载成流插入和流提取:
cpp
std::cout << x << y;
这时它们不再是位移运算,而是函数调用,返回 std::ostream&。
9.4 赋值和复合赋值
cpp
x = 1;
x += 1;
x -= 1;
x *= 2;
x /= 2;
x %= 2;
x &= mask;
x |= mask;
x ^= mask;
x <<= 1;
x >>= 1;
内置赋值表达式的结果是 lvalue,指向左操作数。赋值是右结合的:
cpp
a = b = c; // a = (b = c)
复合赋值先做运算,再赋值。x += 1 大致等价于 x = x + 1,但 x 只求值一次。
9.5 逗号
cpp
a, b
逗号表达式先求值 a,丢弃结果,再求值 b,整个表达式的类型和值类别与 b 相同。
cpp
int a = 1, b = 2;
(a, b) = 10; // 合法:逗号表达式的结果是 b,b 是 lvalue
要注意,函数参数里的逗号、声明里的逗号,都不是逗号运算符:
cpp
f(a, b); // 两个参数
f((a, b)); // 一个参数,值是 b
int x = 1, y = 2; // 两个声明符,不是逗号表达式
10. 成员访问
成员访问有四种写法:
cpp
s.m
p->m
s.*mp
p->*mp
10.1 点号
cpp
struct S { int n; };
S s{1};
s.n = 2; // s.n 是 lvalue
s.m 的值类别取决于 s 和成员的种类:
s是 lvalue,m是数据成员:s.m是 lvalue。s是 rvalue,m是非引用类型的数据成员:s.m是 xvalue。m是成员函数或枚举项:s.m是 prvalue。
cpp
S{2}.n; // xvalue
std::move(s).n; // xvalue
如果 m 是引用类型的数据成员,s.m 仍然是 lvalue,因为引用本身不产生新的对象,访问它得到的是被引用的对象。
10.2 箭头
cpp
S* p = &s;
p->n = 2;
对内置指针,p->m 等价于 (*p).m。*p 是 lvalue,所以 p->m 通常是 lvalue。重载 operator-> 之后,这个等价关系不一定成立,要看重载的实现。
10.3 成员指针
cpp
struct S { int n; };
int S::* mp = &S::n;
S s{1};
s.*mp = 2; // s 是 lvalue,结果是 lvalue
S{2}.*mp; // s 是 rvalue,结果是 xvalue
.* 和 ->* 的规则和点号类似:对象是 lvalue,结果通常是 lvalue;对象是 rvalue,结果是 xvalue。成员指针指向成员函数时,结果是 prvalue。
10.4 this
cpp
struct S {
void f() {
this->n = 1;
}
int n;
};
this 是一个 prvalue 指针,类型是 S*。在 const 成员函数里,类型是 const S*。
this 不能被赋值,也不能取地址(&this 不合法)。它可以参与表达式:
cpp
S* p = this; // 拷贝指针
S& r = *this; // lvalue
S&& rr = std::move(*this); // xvalue
10.5 成员函数调用
cpp
s.f();
p->f();
s.f 本身是 prvalue(成员函数名),但 s.f() 是一个函数调用表达式。它的类型是返回类型,值类别看返回类型:
cpp
struct S {
int& get(); // 返回 lvalue
int value(); // 返回 prvalue
S&& move(); // 返回 xvalue
};
10.6 引用限定符
成员函数可以在参数列表后面加 & 或 &&,限制它只能在左值或右值对象上调用:
cpp
struct S {
void f() &; // 只能对左值调用
void f() &&; // 只能对右值调用
};
S s;
s.f(); // 调用 &
S{}.f(); // 调用 &&
std::move(s).f(); // 调用 &&
如果某个重载返回内部成员的引用,可以删掉 && 版本,防止在临时对象上调用后拿到悬垂引用:
cpp
const std::string& name() const &;
const std::string& name() const && = delete;
11. 下标
cpp
a[i]
p[i]
内置下标表达式 a[i] 等价于 *(a + i)。
值类别规则:
a是数组 lvalue,或者a是指针:结果是 lvalue。a是数组 rvalue:结果是 xvalue。
cpp
int a[3] = {1, 2, 3};
a[0] = 10; // a[0] 是 lvalue
int* p = a;
p[1] = 20; // p[1] 是 lvalue
i[a] 也是合法的,等价于 a[i],因为加法的交换性:
cpp
2[a] = 30; // 等价于 a[2] = 30
重载 operator[] 之后,返回类型决定值类别:
cpp
struct S {
int& operator[](int i); // 返回 lvalue
int operator[](int i) const; // 返回 prvalue
};
std::vector<bool> 是一个特殊的例子。它的 operator[] 返回一个代理对象(proxy),不是 bool&:
cpp
std::vector<bool> v = {true, false};
auto b = v[0]; // b 的类型是 std::vector<bool>::reference,不是 bool
b = true; // 通过代理写入 v[0]
// bool& r = v[0]; // 错误:不能把非 const 左值引用绑到代理 prvalue
代理对象让 vector<bool> 可以按位存储,但也带来了类型上的意外。后面会再讲。
12. 函数调用
cpp
f()
f(1, 2)
obj.f()
p->f()
函数调用表达式的类型是函数返回类型去掉引用后的类型。值类别取决于返回类型是不是引用:
cpp
int f(); // f() 是 prvalue,类型 int
int& g(); // g() 是 lvalue,类型 int
int&& h(); // h() 是 xvalue,类型 int
void v(); // v() 是 prvalue,类型 void
12.1 重载决议
调用函数时,编译器要从一组同名函数里选一个最匹配的。这个过程叫重载决议。它看:
- 实参的类型和值类别。
- 形参的类型。
- 隐式转换的优劣。
- 模板推导的结果。
cpp
void f(int);
void f(double);
f(1); // 选 f(int)
f(1.0); // 选 f(double)
值类别也参与重载决议:
cpp
void g(const std::string&);
void g(std::string&&);
std::string s = "hello";
g(s); // const std::string&
g(std::string("hi")); // std::string&&
g(std::move(s)); // std::string&&
12.2 参数求值顺序
C++17 起,函数调用表达式中,函数名先于所有实参求值;实参之间是不确定顺序(indeterminately sequenced):可能从左到右,也可能从右到左,但不会交错执行。
cpp
f(i++, i++); // C++17 起:顺序不定,但不是未定义行为
C++17 之前,实参之间是无序 (unsequenced)的,两个 i++ 会产生未定义行为。
12.3 默认参数
cpp
void f(int x, int y = 10);
f(1); // 等价于 f(1, 10)
f(1, 2); // 使用传入的 2
默认参数在调用点求值。默认参数不能使用函数的参数,比如 void f(int a, int b = a); 是非法的;sizeof(a) 这类不求值的操作数是例外。默认参数可以引用全局变量、静态成员等在声明处可见的名字。
12.4 函数指针和成员函数指针
cpp
void f(int);
void (*p)(int) = &f;
p(1); // 通过函数指针调用
struct S { void g(int); };
void (S::*mp)(int) = &S::g;
S s;
(s.*mp)(1); // 通过成员函数指针调用
函数指针调用和普通函数调用在表达式层面没有本质区别,值类别同样看返回类型。
12.5 运算符调用
a + b 对类类型可能调用 operator+。这时它本质上是一个函数调用:
cpp
a + b // 可能调用 operator+(a, b) 或 a.operator+(b)
重载运算符的返回类型决定表达式的值类别。内置 + 返回 prvalue,但重载的 operator+ 可以返回 T&,于是 a + b 变成 lvalue。这一点后面会细讲。
12.6 std::move 和 std::forward 作为表达式
std::move(x) 是一个函数调用,返回 T&&。表达式类型是 T,值类别是 xvalue。它不移动任何东西,只改变值类别;真正的移动发生在后续的移动构造或移动赋值里。
cpp
std::string s = "hello";
std::move(s); // 类型 std::string,值类别 xvalue
std::forward<T>(x) 也是函数调用,返回类型由 T 决定:
T是U&:返回U&,值是 lvalue。T是U:返回U&&,值是 xvalue。
cpp
template <class T>
void wrapper(T&& x) {
sink(std::forward<T>(x)); // 保持实参原来的值类别
}
std::forward 只做有条件的转换,不会自己搬数据。
13. 条件表达式
cpp
cond ? a : b
条件运算符先计算 cond,再根据真假选择计算 a 或 b。只有被选中的那个分支会求值。
cpp
int x = 1;
int y = 2;
int z = (x > y) ? x : y; // 只计算一个分支
13.1 类型规则
结果类型是 a 和 b 的共同类型。常见情况:
- 两个都是算术类型:做 usual arithmetic conversions。
- 两个都是指针:做指针转换和 qualification conversion。
- 一个是
nullptr,另一个是指针:结果是指针类型。 - 两个都是类类型:尝试互相转换,选择共同类型。
- 一个是
throw表达式:结果类型和值类别取另一个操作数。
cpp
int x = 1;
double y = 2.0;
auto z = x > y ? x : y; // z 是 double
13.2 值类别规则
- 两个操作数都是同类型、同值类别的 glvalue:结果保持该类型和值类别。
- 否则,结果是 prvalue。
cpp
int a = 1, b = 2;
(a < b ? a : b) = 10; // 合法:两个都是 lvalue,结果也是 lvalue
int c = 3;
// (a < b ? a : c) = 10; // 如果 a、c 类型相同,仍然合法
// (a < b ? a : 3) = 10; // 错误:一个是 lvalue,一个是 prvalue,结果是 prvalue
如果两个分支类型不同,需要转换,结果通常是 prvalue,不能再赋值:
cpp
long y = 2;
int x = 1;
// (x > y ? x : y) = 10; // 错误:结果经过转换,是 prvalue
13.3 解析陷阱
条件运算符的优先级低于赋值,但它的第三个操作数是 assignment-expression,所以:
cpp
a ? b : c = d // 解析为 a ? b : (c = d)
a = b ? c : d // 解析为 a = (b ? c : d)
a ? b = c : d // 解析为 a ? (b = c) : d
如果想对整个条件表达式赋值,需要加括号:
cpp
(a ? b : c) = d;
13.4 嵌套
条件运算符是右结合的:
cpp
a ? b : c ? d : e // a ? b : (c ? d : e)
嵌套太多会影响可读性,建议加括号或改成 if。
14. 逗号表达式
cpp
a, b
逗号表达式先求值 a,丢弃结果,再求值 b。整个表达式的类型和值类别与 b 相同。
cpp
int a = 1, b = 2;
int c = (a++, b++); // c = 2,a 变成 2,b 变成 3
逗号表达式常用于 for 循环:
cpp
for (int i = 0, j = 10; i < j; ++i, --j) {
// ...
}
注意,for 的初始化和递增部分里的逗号,有时是逗号运算符,有时是声明分隔符。int i = 0, j = 10 是声明两个变量;++i, --j 是逗号表达式。
14.1 逗号不是逗号运算符的场合
cpp
f(a, b); // 两个参数
f((a, b)); // 一个参数,值是 b
int x = 1, y = 2; // 两个声明符
int a[3] = {1, 2, 3}; // 初始化列表的分隔符
14.2 重载逗号
逗号运算符可以被重载,但非常少见。重载之后,a, b 变成函数调用,值类别由返回类型决定。读代码时如果看到自定义的 operator,,要格外小心。
15. 赋值表达式
cpp
a = b
a += b
内置赋值表达式的结果是 lvalue,指向左操作数。赋值是右结合的:
cpp
a = b = c; // a = (b = c)
15.1 赋值和初始化的区别
cpp
int x = 1; // 初始化(copy-initialization),不是赋值
x = 2; // 赋值
初始化发生在对象创建时,赋值发生在对象已经存在之后。对于类类型,初始化调用构造函数,赋值调用 operator=。
cpp
std::string s = "hello"; // 构造
s = "world"; // 赋值
15.2 赋值表达式的结果
cpp
int a, b, c;
a = b = c = 1; // 从右往左赋值,结果是 a 的引用
赋值表达式可以作为另一个表达式的一部分:
cpp
int x;
if ((x = f()) != 0) {
// 使用 x
}
这种写法能工作,但可读性一般。很多代码规范建议把赋值和比较分开写。
15.3 复合赋值
cpp
x += 1; // 大致等价于 x = x + 1
x *= 2; // 大致等价于 x = x * 2
复合赋值只对左操作数求值一次,而且结果类型是左操作数的类型。对于重载类型,operator+= 可能做完全不同的事情。
15.4 赋值左边的要求
内置赋值要求左操作数是可修改的 lvalue:
cpp
int x = 1;
x = 2; // OK
// 1 = 2; // 错误:1 是 prvalue
// const int c = 1;
// c = 2; // 错误:c 是 const lvalue
类类型的赋值可能通过重载 operator= 实现。即使左操作数是 prvalue,只要 operator= 能绑定,也可能合法:
cpp
struct S { S& operator=(const S&); };
S{} = S{}; // 合法:调用临时对象的 operator=
这看起来很奇怪,但语法上成立。实际代码里不要依赖这种写法。
16. 强制转换
C++ 有四种具名转换,加上 C 风格转换和函数式转换。
cpp
static_cast<T>(x)
dynamic_cast<T>(x)
const_cast<T>(x)
reinterpret_cast<T>(x)
(T)x
T(x)
16.1 static_cast
static_cast 做编译期能确定的转换:
- 算术类型之间的转换。
- 指针/引用在继承层次中的上行转换。
void*和具体指针之间的转换。- 显式调用构造函数。
- 转换成右值引用(
std::move的本质)。
值类别取决于目标类型:
cpp
static_cast<int>(x) // prvalue
static_cast<int&>(x) // lvalue
static_cast<int&&>(x) // xvalue
cpp
std::string s = "hello";
std::string&& r = static_cast<std::string&&>(s); // xvalue
16.2 dynamic_cast
dynamic_cast 用于多态类型的安全向下转换。指针转换失败返回 nullptr,引用转换失败抛出 std::bad_cast。
cpp
struct Base { virtual ~Base() = default; };
struct Derived : Base {};
Base* b = new Derived;
Derived* d = dynamic_cast<Derived*>(b); // 成功
值类别同样看目标类型:转换到 T& 是 lvalue,转换到 T&& 是 xvalue,转换到 T 是 prvalue。
16.3 const_cast
const_cast 添加或移除 const / volatile:
cpp
const int x = 1;
int& r = const_cast<int&>(x); // 语法上可以,但修改 x 是未定义行为
如果原对象本身是 const,通过 const_cast 修改它是未定义行为。const_cast 主要用于调用没有 const 正确性的老接口。
16.4 reinterpret_cast
reinterpret_cast 重新解释位模式,几乎不做转换:
cpp
int x = 42;
int* p = &x;
void* v = reinterpret_cast<void*>(p);
它非常危险,除非你很清楚自己在做什么,否则不要用。
16.5 C 风格转换和函数式转换
cpp
(T)x // C 风格转换
T(x) // 函数式转换
C 风格转换会依次尝试 const_cast、static_cast、reinterpret_cast,具体选哪个由编译器决定。它不容易看出实际发生了什么,现代 C++ 建议使用具名转换。
函数式转换 T(x) 大致等价于 static_cast<T>(x),但对于类类型可能调用构造函数。T{x} 是列表初始化,会检查窄化转换:
cpp
int x{3.14}; // 错误:窄化转换
int y = 3.14; // 可以,截断
16.6 转换成 void
cpp
(void)x;
转换成 void 会丢弃值,只保留副作用。它常用于抑制"未使用变量"的警告。
17. sizeof、alignof、decltype、typeid、noexcept
这五个运算符有一个共同点:它们主要关心类型或编译期属性,不一定对操作数求值。
17.1 sizeof
cpp
sizeof(T)
sizeof expr
sizeof 返回 std::size_t,是 prvalue。它的操作数通常不求值:
cpp
int x = 1;
std::size_t n = sizeof(x++); // x 不会加一
sizeof 一个数组得到整个数组的大小;sizeof 一个指针得到指针的大小:
cpp
int a[10];
sizeof(a); // 通常是 40
int* p = a;
sizeof(p); // 通常是 8
sizeof 一个引用得到被引用类型的大小;sizeof 一个函数不合法;sizeof(void) 在标准 C++ 里不合法(有些编译器作为扩展接受)。
17.2 alignof
cpp
alignof(T) // prvalue,std::size_t
返回类型的对齐要求。
17.3 decltype
cpp
decltype(expr)
decltype 的结果类型分两种情况:
- 如果
expr是没有括号的标识表达式,或者没有括号的类成员访问,结果是这个表达式命名的实体的声明类型。 - 否则,根据表达式的值类别:
- xvalue:
T&& - lvalue:
T& - prvalue:
T
- xvalue:
cpp
int x = 0;
const int cx = 0;
decltype(x) a = 1; // int
decltype((x)) b = a; // int&
decltype(cx) c = 1; // const int
decltype((cx)) d = c; // const int&
decltype(std::move(x)) e = 0; // int&&
decltype 的操作数不求值。decltype(x++) 不会让 x 加一。
decltype(auto) 用 decltype 的规则推导类型,会保留引用和 const:
cpp
decltype(auto) f1() {
int x = 0;
return x; // int
}
decltype(auto) f2() {
int x = 0;
return (x); // int&,返回局部变量的引用,悬垂
}
17.4 typeid
cpp
typeid(expr)
typeid(T)
typeid 返回一个 lvalue,类型是 const std::type_info。
如果操作数是多态类类型的 glvalue,typeid 会求值,以获取动态类型;否则不求值:
cpp
struct Base { virtual ~Base() = default; };
struct Derived : Base {};
Base* p = new Derived;
typeid(*p) == typeid(Derived); // true,动态类型
17.5 noexcept
cpp
noexcept(expr) // prvalue,bool
noexcept(expr) 判断表达式是否保证不抛异常。操作数不求值:
cpp
noexcept(f()); // 只看 f 的 noexcept 声明,不调用 f
18. new、delete、throw
18.1 new
cpp
new T
new T(args...)
new T[n]
new T 表达式分配内存、构造对象,返回 T*,是 prvalue。如果分配失败,默认抛出 std::bad_alloc。
cpp
int* p = new int(42);
delete p;
定位 new(placement new)在已有内存上构造对象,不分配内存:
cpp
alignas(T) unsigned char buf[sizeof(T)];
T* p = new (buf) T(args...);
new (std::nothrow) T 在分配失败时返回 nullptr,不抛异常。
18.2 delete
cpp
delete p;
delete[] p;
delete 表达式是 prvalue,类型是 void。它先调用析构函数,再释放内存。
delete 和 new 必须匹配:new[] 配 delete[],new 配 delete。混用是未定义行为。重复 delete 同一块内存也是未定义行为。
18.3 throw
cpp
throw x;
throw;
throw x 是 prvalue,类型是 void。它把 x 拷贝或移动到异常对象里,然后开始栈展开。
throw; 只能出现在 catch 块里,用来重新抛出当前异常。
throw 表达式可以作为条件运算符的分支:
cpp
int x = cond ? value : throw std::runtime_error("bad");
因为 throw 的类型是 void,条件运算符会取另一个分支的类型。
19. lambda 表达式
cpp
auto f = [](int x) { return x * x; };
lambda 表达式是一个 prvalue,类型是一个唯一的闭包类型。闭包类型没有名字,只能用 auto 或模板参数接收。
19.1 捕获
cpp
int a = 1;
auto f1 = [a] { return a; }; // 按值捕获
auto f2 = [&a] { return a; }; // 按引用捕获
auto f3 = [=] { return a; }; // 默认按值
auto f4 = [&] { return a; }; // 默认按引用
auto f5 = [x = a + 1] { return x; }; // 初始化捕获(C++14)
按值捕获的变量在闭包对象里是一份拷贝。按引用捕获的变量在闭包对象里是一个引用, lambda 活得比变量久就会悬垂。
19.2 mutable 和 const
lambda 的 operator() 默认是 const 的,不能修改按值捕获的变量。加 mutable 可以去掉 const:
cpp
auto f = [x = 0]() mutable { return ++x; };
f(); // 1
f(); // 2
19.3 立即调用的 lambda
cpp
int x = [] { return 42; }();
lambda 表达式是 prvalue,后面加 () 就是调用它。立即调用的 lambda 常用于初始化复杂对象:
cpp
const auto config = [] {
Config c;
c.load("config.ini");
return c;
}();
19.4 无捕获 lambda 和函数指针
无捕获的 lambda 可以隐式转换成函数指针:
cpp
void (*p)(int) = [](int x) { /* ... */ };
有捕获的 lambda 不能转换成函数指针,因为需要保存捕获的状态。
20. C++17/20/23 的新表达式
20.1 折叠表达式(C++17)
cpp
template <class... Args>
auto sum(Args... args) {
return (args + ...);
}
折叠表达式把参数包展开成一个表达式。它的类型和值类别取决于运算符和操作数。
20.2 requires 表达式(C++20)
cpp
template <class T>
concept Addable = requires(T a, T b) {
{ a + b } -> std::convertible_to<T>;
};
requires 表达式是 prvalue,类型是 bool。它的操作数不求值,只检查表达式是否合法。
20.3 co_await 和 co_yield(C++20)
cpp
auto result = co_await task;
co_yield value;
co_await 等待一个 awaitable 对象,恢复后表达式的类型和值类别由 await_resume() 决定。co_yield 把一个值交给调用方,然后挂起。
20.4 三路比较(C++20)
cpp
auto cmp = a <=> b;
<=> 返回一个比较类别类型的 prvalue,通常是 std::strong_ordering、std::weak_ordering 或 std::partial_ordering。
20.5 其他
if consteval是语句,不是表达式。consteval是函数说明符,不是表达式。std::forward_like是函数调用,不是新的表达式类别。std::move_only_function是类型,不是表达式。
第三部分 类型、值类别、转换和求值
21. 类型怎么定
表达式的类型可以从下往上推:
- 名字:声明时的类型。
- 字面量:字面量本身的类型。
- 一元/二元运算:运算符的结果类型规则。
- 函数调用:函数的返回类型。
- 成员访问:成员的类型。
- 强制转换:目标类型。
decltype:按decltype规则。auto:按auto推导规则;会丢掉引用和顶层 const。decltype(auto):按decltype规则,保留引用和 const。
有一个规则容易被忽略:表达式的类型会去掉引用 。变量声明为 int& r,表达式 r 的类型是 int,值类别是 lvalue;函数返回 int&&,调用表达式的类型是 int,值类别是 xvalue。引用信息不会消失,它体现在值类别上。
decltype 是一个例外:它能看到引用。decltype(x) 是 int,decltype((x)) 是 int&;decltype(g()) 是 int&,其中 g 返回 int&。所以 decltype 经常被用来"反推"表达式或实体的引用类型。
21.1 数组和函数的退化
数组和函数在大多数表达式里会退化:
cpp
int a[3];
int* p = a; // 数组退化成指针
void f();
void (*fp)() = f; // 函数退化成函数指针
不退化的场合:
sizeof(a):得到整个数组的大小。&a:得到指向数组的指针,类型是int(*)[3]。decltype(a):得到int[3]。- 绑定到引用:
int (&r)[3] = a;。
21.2 auto 的推导
cpp
const int cx = 0;
int value = 0;
int& rx = value;
auto a = cx; // int,const 丢了
auto b = rx; // int,引用丢了,变成拷贝
auto& c = cx; // const int&
auto&& d = rx; // int&
auto&& 是转发引用,会保留值类别:
cpp
auto&& e = 42; // int&&
auto&& f = cx; // const int&
auto 和花括号初始化列表一起用时,规则有点绕:
cpp
auto a = {1, 2, 3}; // std::initializer_list<int>
auto b{1}; // C++17 起是 int;C++11/14 是 std::initializer_list<int>
写 auto 时尽量避开这种写法。需要列表时,直接写 std::initializer_list<int> 更清楚。
21.3 decltype 和 decltype(auto)
cpp
int x = 0;
decltype(x) a = 1; // int
decltype((x)) b = a; // int&
decltype(auto) c = x; // int
decltype(auto) d = (x); // int&
这里的关键区别是:decltype(x) 看声明类型,decltype((x)) 看表达式的值类别。多一对括号,结果可能完全不同。
22. 值类别怎么定
值类别只看表达式本身,不看它的类型。下面是一棵判断树。
text
这个表达式是什么?
├─ 是名字?
│ ├─ 变量名 → lvalue
│ ├─ 函数名 → lvalue
│ └─ 枚举项 → prvalue
├─ 是字面量?
│ ├─ 字符串字面量 → lvalue
│ └─ 其他字面量 → prvalue
├─ 是 std::move(x) 或 static_cast<T&&>(x)? → xvalue(T 是非引用类型时)
├─ 是函数调用?
│ └─ 看返回类型:T → prvalue,T& → lvalue,T&& → xvalue
├─ 是成员访问?
│ └─ 看对象和成员:对象 lvalue → lvalue;对象 rvalue 且成员是非引用数据成员 → xvalue;成员函数/枚举项 → prvalue
├─ 是内置运算符?
│ └─ 按运算符规则
├─ 是重载运算符?
│ └─ 看返回类型
└─ 是条件/逗号表达式?
└─ 看操作数
22.1 两个问题
如果不确定,问自己两个问题:
- 这个表达式有没有身份? 能不能判断它和另一个表达式指的是不是同一个对象?
- 这个对象的资源能不能被搬走? 它是不是马上就要销毁了?
text
有身份 + 不能搬 → lvalue
有身份 + 能搬 → xvalue
没身份 + 能搬 → prvalue
没身份 + 不能搬 → 不存在这种类别
22.2 类型和值类别是两件事
cpp
int&& r = 42; // r 的声明类型是 int&&;表达式 r 的类型是 int,值类别是 lvalue
std::move(r); // 返回类型是 int&&;表达式类型是 int,值类别是 xvalue
42; // 类型是 int,值类别是 prvalue
22.3 有名字的右值引用是左值
这是最容易错的一条:
cpp
void f(int&& x) {
// x 的类型是 int&&,但 x 是 lvalue
// f(x); // 错误
f(std::move(x)); // OK
}
原因:x 是一个有名字的形参,有地址,在函数体里就是普通对象。声明类型 int&& 只说明调用方传进来的是右值,不说明函数体里它还是右值;表达式 x 的类型是 int,值类别是 lvalue。
23. 隐式转换
表达式在参与运算、传参、初始化时,可能发生隐式转换。
23.1 左值到右值转换
大多数运算符需要的是"值",不是"对象"。所以 lvalue 会转换成 prvalue,读取对象的值:
cpp
int x = 1;
int y = x + 1; // x 被读成值
这个转换叫 lvalue-to-rvalue conversion。它读取对象的内容,丢弃对象的身份。
23.2 数组到指针、函数到指针
cpp
int a[3];
int* p = a; // 数组退化成指针
void f();
void (*fp)() = f; // 函数退化成函数指针
这两种退化在大多数表达式里自动发生,但 sizeof、&、decltype、绑定引用时不会。
23.3 限定转换
cpp
int x = 1;
const int& r = x; // 加 const,安全
// int& r2 = static_cast<const int&>(x); // 错误:不能去掉 const
限定转换可以添加 cv 限定,不能随意去掉。
23.4 整数提升和 usual arithmetic conversions
cpp
char c = 'a';
int x = c + 1; // c 提升成 int
int i = 1;
double d = 2.0;
auto r = i + d; // i 转换成 double,r 是 double
整数提升把小于 int 的整数类型提升到 int。usual arithmetic conversions 把两个算术操作数转换成共同的类型。
23.5 用户定义转换
类可以通过构造函数或转换运算符提供转换:
cpp
struct Celsius {
double value;
operator double() const { return value; }
};
Celsius c{36.5};
double d = c; // 调用 operator double()
一次隐式转换序列最多包含一个用户定义转换。
23.6 列表初始化的窄化检查
cpp
int x = 3.14; // 可以,截断
int y{3.14}; // 错误:窄化转换
列表初始化禁止窄化转换,比如把 double 塞进 int、把大整数塞进小整数。这是它比圆括号初始化更安全的地方。
24. 重载决议
重载决议决定一个函数调用选哪个函数。它看实参和形参的匹配程度。
24.1 const 引用和右值引用
cpp
void f(const std::string&);
void f(std::string&&);
- 左值只能绑定到
const std::string&。 - 右值两者都能绑定,但
std::string&&更匹配。
24.2 按值和右值引用
cpp
void g(int);
void g(int&&);
// g(1); // 二义性:两个都是精确匹配
按值参数和右值引用参数对右值实参都是精确匹配,编译器无法区分。
24.3 转发引用和引用折叠
cpp
template <class T>
void f(T&& x);
T&& 在模板推导时是转发引用,可以绑定左值和右值。它之所以能这样,是因为引用折叠:
text
T& & -> T&
T& && -> T&
T&& & -> T&
T&& && -> T&&
传左值时,T 被推导成 U&,T&& 折叠成 U&;传右值时,T 是 U,T&& 保持 U&&。std::forward<T> 利用这一点,把参数原样传下去。
T&& 的匹配能力很强,设计重载时要小心,避免它抢走本来应该走其他重载的调用。
24.4 引用限定符
cpp
struct S {
void f() &;
void f() &&;
};
S s;
s.f(); // &
S{}.f(); // &&
std::move(s).f(); // &&
引用限定符让成员函数根据对象的左值/右值状态选择不同的实现。
25. 临时对象和生命周期
临时对象是在表达式求值过程中创建的、没有名字的对象。
cpp
std::string s = std::string("hello"); // 临时 std::string
int x = f(); // f 返回的临时值
25.1 完整表达式
临时对象通常活到完整表达式结束。完整表达式是"不属于任何更大表达式"的表达式,常见于:
- 一条表达式语句。
- 一个变量的初始化器。
- 一个
return语句的返回值。 - 一个条件表达式的分支。
cpp
f(std::string("hello")); // 临时 string 活到 f 调用结束
25.2 生命周期延长
把临时对象绑定到引用,生命周期会延长到引用的生命周期:
cpp
const std::string& r = std::string("hello"); // 安全
std::string&& rr = std::string("hello"); // 安全
但延长只在"引用直接绑定到临时对象"时有效。下面这些情况会失效:
cpp
const std::string& bad1() {
return std::string("hello"); // 悬垂
}
const std::string& id(const std::string& s) {
return s;
}
const std::string& bad2 = id(std::string("hello")); // 悬垂
std::string&& bad3 = std::move(std::string("hello")); // 悬垂
const int& bad4 = std::max(1, 2); // 悬垂
25.3 C++17 的临时物化
C++17 起,prvalue 不再是一个临时对象,而是一个"初始化配方"。它会在需要的时候物化成临时对象:
cpp
std::string s = std::string("hello"); // 直接在 s 的位置构造
const std::string& r = std::string("hello"); // 物化成临时对象,绑定到 r
这解释了为什么 C++17 能保证某些拷贝省略,也解释了为什么 std::move(T{}) 不延长生命周期:std::move 返回的是 xvalue,不是 prvalue,物化后的临时对象不会被延长。
25.4 常见的悬垂场景
- 返回局部变量的引用或指针。
- 把引用成员绑定到构造函数的参数。
- 绑定
std::max/std::min的返回值到临时对象。 - 用
std::move包装临时对象后再绑定引用。 std::string_view/std::span指向临时容器。- 范围 for 的范围表达式返回局部引用。
26. 求值顺序和副作用
C++ 的求值顺序规则在 C++17 有较大变化。理解这些规则,能解释很多"同一行代码,换个编译器结果不一样"的现象。
26.1 三种关系
- 先于(sequenced before):A 完全在 B 之前完成。
- 不确定顺序(indeterminately sequenced):A 和 B 谁先谁后不确定,但不会交错执行。
- 无序(unsequenced):A 和 B 可以任意交错。
如果两个修改同一对象的副作用无序,行为未定义。
26.2 C++17 的规则
C++17 规定了一部分运算符的求值顺序:
| 表达式 | 顺序 |
|-------------------|-------------------|-----|------------|
| a.b | a 先于 b |
| a->b | a 先于 b |
| a->*b | a 先于 b |
| a[b] | a 先于 b |
| a << b、a >> b | a 先于 b |
| b = a、b @= a | a 先于 b(右边先算) |
| a(b1, b2, b3) | 函数名先于实参;实参之间不确定顺序 |
| a && b、`a | | b` | 左边先于右边,且短路 |
| a ? b : c | a 先于 b 或 c |
| a, b | a 先于 b |
| new T(args...) | 分配先于构造参数(C++17 起) |
其他二元运算符(比如 a + b)的操作数顺序仍然未指定。
这里说的是内置运算符。重载运算符用运算符写法调用时,遵循对应内置运算符的顺序;如果写成 a.operator=(b) 这种成员函数调用形式,就按函数调用的规则来。
26.3 未定义行为的例子
C++17 之前:
cpp
i = i++ + 2; // 未定义行为
f(i++, i++); // 未定义行为
a[i] = i++; // 未定义行为
C++17 起,赋值右边先算,函数实参不确定顺序,所以这些例子不再是未定义行为,但结果可能仍然不符合直觉:
cpp
i = i++ + 2; // C++17 起有确定顺序,但别这么写
f(i++, i++); // 顺序不确定,结果依赖编译器
a[i] = i++; // C++17 起有确定顺序
仍然未定义:
cpp
i = ++i + i++; // 两个操作数无序,且都修改 i
26.4 短路求值
cpp
if (p != nullptr && p->value > 0) {
// p 为空时,右边不执行
}
&& 和 || 的左边先算,必要时才算右边。重载之后,短路消失:
cpp
struct S {
bool operator&&(const S&) const;
};
S a, b;
a && b; // 调用 operator&&,两个操作数都求值
26.5 函数实参的顺序
cpp
f(i++, i++); // 顺序不确定
C++17 起,实参之间不确定顺序:可能先算左边的 i++,也可能先算右边的,但不会交错。结果可能是 f(0, 1) 或 f(1, 0),取决于编译器。
不要写依赖实参顺序的代码。如果确实需要顺序,拆成多条语句:
cpp
int a = i++;
int b = i++;
f(a, b);
27. 重载运算符和代理对象
27.1 重载运算符是函数调用
cpp
struct S {};
S operator+(const S&, const S&);
S a, b;
a + b; // 调用 operator+
重载运算符的值类别由返回类型决定,表达式类型是返回类型去掉引用:
cpp
struct S {
S& operator+=(const S&); // 返回 S&;表达式类型 S,值类别 lvalue
S operator+(const S&); // 返回 S;表达式类型 S,值类别 prvalue
};
内置 + 返回 prvalue,但重载的 operator+ 可以返回 T&,于是 a + b 变成 lvalue。读代码时不能只看运算符符号,还要看它的重载。
27.2 operator&& 和 operator||
重载 operator&& 和 operator|| 会失去短路求值:
cpp
struct S {
bool operator&&(const S&) const;
};
S a, b;
a && b; // 两个操作数都会求值
这是因为重载之后,a && b 变成了函数调用,函数实参必须先求值。
27.3 operator,
重载逗号运算符非常少见,而且容易让人误解。除非有很强的理由,否则不要重载它。
27.4 vector 的代理
cpp
std::vector<bool> v = {true, false};
auto b = v[0]; // b 是 std::vector<bool>::reference,不是 bool
b = true; // 通过代理写入 v[0]
// bool& r = v[0]; // 错误:v[0] 返回的是 prvalue 代理
bool real = v[0]; // 转换成 bool
代理对象让 vector<bool> 可以按位存储,但也让 auto 推导出意料之外的类型。需要真正的 bool 时,写 bool b = v[0];。
27.5 表达式模板
一些数值库(比如 Eigen、Blaze)用表达式模板实现惰性求值:
cpp
auto expr = a + b + c; // expr 可能不是结果,而是一个表达式对象
表达式对象通常保存操作数的引用,真正计算发生在赋值给具体类型时:
cpp
Matrix result = a + b + c; // 这时才计算
如果 auto 保存了表达式对象,而它引用的临时对象已经销毁,就会悬垂:
cpp
auto expr = makeMatrix() + makeMatrix(); // 可能悬垂
Matrix result = makeMatrix() + makeMatrix(); // 安全
使用这类库时,先看文档,确认 auto 和具体类型的行为。
28. 表达式模板和惰性求值
表达式模板把"表达式"本身表示成一个对象。它延迟计算,把多个运算融合在一起,减少临时对象和内存访问。
cpp
// 伪代码
auto expr = a + b * c; // expr 是一棵表达式树
double x = expr[0]; // 到这里才真正计算
优点:
- 避免中间临时对象。
- 把多个运算融合成一个循环。
- 提高数值计算的性能。
缺点:
auto推导出的类型可能不是你以为的结果类型。- 表达式对象可能保存引用,生命周期管理变得复杂。
- 错误信息通常很长。
使用表达式模板的库时,常见的建议是:
- 需要具体结果时,显式写成具体类型(
Matrix result = ...;)。 - 不要长期保存
auto推导出的表达式对象。 - 注意临时对象的生命周期。
第四部分 上一篇文章里的表达式逐个拆
29. 速查表
下面这张表把上一篇文章里出现的表达式集中起来。先看类型和值类别,再看后面的详细解释。
表里的"类型"是表达式本身的类型,已经去掉引用。变量声明类型、函数返回类型可能带引用,引用信息体现在"值类别"一列。
| 表达式 | 类型(去掉引用) | 值类别 | 关键点 |
|---|---|---|---|
x(变量) |
声明类型去掉引用 | lvalue | 有名字就是左值 |
x(枚举项) |
枚举类型 | prvalue | 枚举项不是对象 |
42 |
int |
prvalue | 普通字面量 |
true |
bool |
prvalue | 布尔字面量 |
nullptr |
std::nullptr_t |
prvalue | 空指针字面量 |
"hello" |
const char[6] |
lvalue | 字符串字面量是左值 |
x + 1 |
共同类型 | prvalue | 算术运算 |
x = 1 |
int |
lvalue | 赋值返回左操作数 |
++x |
int |
lvalue | 前置自增返回对象本身 |
x++ |
int |
prvalue | 后置自增返回旧值 |
*p |
T |
lvalue | 解引用 |
&x |
T* |
prvalue | 地址值 |
a[i] |
T |
lvalue | 内置下标,数组是左值时 |
a, b |
b 的类型 |
与 b 相同 |
逗号取右操作数 |
cond ? a : b |
共同类型 | 看两个分支 | 同为左值才是左值 |
f() 返回 T |
T |
prvalue | 按值返回 |
f() 返回 T& |
T |
lvalue | 返回左值引用 |
f() 返回 T&& |
T |
xvalue | 返回右值引用 |
s.m(s 左值) |
成员类型 | lvalue | 成员访问 |
S{}.m |
成员类型 | xvalue | 临时对象的成员 |
std::move(x) |
T |
xvalue | 无条件转成右值 |
static_cast<T&&>(x) |
T |
xvalue | 显式转成右值引用 |
this |
T* |
prvalue | 指针值 |
typeid(x) |
const std::type_info |
lvalue | 返回类型信息 |
throw x |
void |
prvalue | 抛出异常 |
sizeof(x) |
std::size_t |
prvalue | 不求值 |
new T |
T* |
prvalue | 分配并构造 |
delete p |
void |
prvalue | 析构并释放 |
*p++ |
T |
lvalue | 解析为 *(p++) |
++*p |
T |
lvalue | 解析为 ++(*p) |
*++p |
T |
lvalue | 解析为 *(++p) |
std::move(*p) |
T |
xvalue | 移动所指对象 |
*std::move(p) |
T |
lvalue | 移动指针本身,再解引用 |
f(std::move(x)) |
返回类型去掉引用 | 看返回类型 | 实参是 xvalue |
std::cout << x << y |
std::ostream |
lvalue | 链式调用 |
a[i] = i++ |
int |
lvalue | C++17 起有确定顺序 |
[] { return 1; }() |
int |
prvalue | 立即调用 lambda |
30. 容易看错的十几个表达式
30.1 std::move(*p) 和 *std::move(p)
cpp
std::move(*p); // 先 *p,得到类型 T、lvalue;再转成 xvalue,表达式类型仍是 T
*std::move(p); // 先 std::move(p),返回类型 T*&&、表达式类型 T*、xvalue;解引用后类型 T、lvalue
前者想移动 p 指向的对象;后者只是把指针本身转成右值,解引用之后仍然是 lvalue。移动一个指针没有意义,因为指针是标量类型。
30.2 s.m 和 S{}.m
cpp
S s;
s.m; // lvalue
S{}.m; // xvalue
区别不在成员,而在对象。s 是 lvalue,S{} 是 prvalue。
30.3 *p++、++*p、*++p
cpp
*p++ // *(p++):先取旧指针指向的值,再让 p 加一
++*p // ++(*p):把 p 指向的值加一
*++p // *(++p):先让 p 加一,再取新指针指向的值
三个表达式的副作用不同,读代码时要逐个拆。
30.4 a = b 是 lvalue
cpp
(a = b) = c; // 合法:赋值表达式的结果是左操作数
内置赋值返回左操作数的引用,所以可以连续赋值:
cpp
a = b = c; // a = (b = c)
30.5 a, b 的值类别看 b
cpp
int a = 1, b = 2;
(a, b) = 10; // 合法:b 是 lvalue
(a, 5) = 10; // 错误:5 是 prvalue
30.6 条件表达式的值类别
cpp
(a < b ? a : b) = 10; // 两个都是 lvalue,结果 lvalue
(a < b ? a : 5) = 10; // 一个是 prvalue,结果 prvalue,不能赋值
30.7 f() 返回 T&& 是 xvalue
cpp
T&& f();
f(); // 类型 T,值类别 xvalue
即使 f 返回的是右值引用,调用表达式仍然是 xvalue。表达式类型是去掉引用后的 T,T&& 是返回类型。它能不能绑定到左值引用,要看返回类型。
30.8 this 是 prvalue
cpp
this // prvalue,类型 T*
*this // lvalue,类型 T&
std::move(*this) // xvalue
this 本身是一个指针值,不能赋值;*this 才是对象。
30.9 typeid(x) 是 lvalue
cpp
typeid(x) // 类型 const std::type_info,lvalue
typeid 返回的是类型信息的引用,不是 prvalue;表达式类型是 const std::type_info。
30.10 sizeof(x++) 不求值
cpp
int x = 1;
sizeof(x++); // x 仍然是 1
sizeof、decltype、noexcept 的操作数通常不求值,不要依赖其中的副作用。
30.11 new T 是 prvalue 指针
cpp
new T // prvalue,类型 T*
delete p // prvalue,类型 void
new 返回指针值,delete 返回 void。它们都不是 lvalue。
30.12 throw x 是 prvalue void
cpp
throw x; // prvalue,类型 void
throw 表达式没有值,只用来抛出异常。它可以作为条件运算符的分支,因为它的类型是 void。
30.13 std::cout << x << y 是 lvalue
cpp
std::cout << x << y; // 返回类型 std::ostream&;表达式类型 std::ostream,lvalue
<< 被重载成流插入运算符,返回 std::ostream&。链式调用能继续,就是因为每次返回的都是同一个流的引用。
30.14 a[i] = i++
cpp
int i = 0;
int a[10];
a[i] = i++;
C++17 之前,这是未定义行为。C++17 起,赋值右边先算,所以 i++ 先执行,a[i] 用的是加一后的 i。结果依赖具体顺序,读代码时不要靠推断,直接拆成多条语句。
30.15 [] { return 1; }()
cpp
int x = [] { return 1; }();
lambda 表达式是 prvalue,后面的 () 调用它。整个表达式是 prvalue,类型是返回类型。
31. 一套通用的拆解流程
遇到复杂表达式,按下面五步走:
第一步:加括号,明确树形
根据优先级和结合性,把表达式拆成子表达式。拿不准就手动加括号。
cpp
*p++ = *q++; // *(p++) = *(q++)
第二步:从叶子往根推类型
先确定变量、字面量、函数调用的类型,再根据运算符规则往根推。
cpp
p // int*
p++ // int*
*(p++) // int&
q++ // int*
*(q++) // int&
*(p++) = *(q++) // int&
第三步:标出每个节点的值类别
cpp
p++ // prvalue
*(p++) // lvalue
q++ // prvalue
*(q++) // lvalue
赋值表达式 // lvalue
第四步:找副作用和求值顺序
cpp
p++ // 修改 p
q++ // 修改 q
赋值 // 修改 *(p++)
C++17 起,赋值右边先于左边。p、q 互不相关时,顺序不影响结果;p、q 指向同一对象时,要特别小心。
第五步:看临时对象和生命周期
cpp
const std::string& r = std::string("hello"); // 生命周期延长,安全
std::string&& r2 = std::move(std::string("hello")); // 不延长,悬垂
一个综合例子
cpp
auto x = f(std::move(v[i])) + g();
拆解:
- 树:
auto x = (f(std::move(v[i])) + g()); - 类型:
v[i]是 lvalue,表达式类型T;std::move(v[i])是 xvalue,表达式类型T(返回类型是T&&);f(...)的类型看f的返回类型去掉引用;g()同理;+的结果是共同类型。 - 值类别:
v[i]是 lvalue;std::move(v[i])是 xvalue;f(...)看返回类型;g()看返回类型;+通常是 prvalue。 - 副作用:
f可能移动v[i];g可能有副作用;+的操作数顺序未指定(C++17 仍如此)。 - 生命周期:
v[i]必须在f调用期间活着;如果f保存了引用,后面可能悬垂。
32. 二十个容易误判的案例
下面这些表达式,很多人第一次都会判断错。每个给一句解释。
int&& r = 42; r是 lvalue。 有名字的右值引用变量是左值。std::move(const_obj)不会移动。 它返回const T&&,移动构造绑不上,会退化成拷贝。return std::move(local);会阻止 NRVO。 直接写return local;更好。a = b是 lvalue。 内置赋值返回左操作数的引用。x++是 prvalue,++x是 lvalue。 后置返回旧值,前置返回对象本身。"hello"是 lvalue。 字符串字面量是const char[N],有固定地址。&x是 prvalue。 取出来的地址是一个临时值。S{}.m是 xvalue。 临时对象的非引用数据成员是 xvalue。a, b的值类别看b。 逗号表达式取右操作数。cond ? a : b的值类别看两个分支。 两者同为 lvalue 才是 lvalue。typeid(x)是 lvalue。 它的表达式类型是const std::type_info,返回的是类型信息的引用。this是 prvalue。 它是一个指针值;*this才是对象。sizeof(x++)不会让x加一。 操作数不求值。decltype(x)和decltype((x))可能不同。 前者看声明类型,后者看值类别。auto会丢掉引用和顶层 const。 需要保留时用auto&、auto&&或decltype(auto)。- 函数实参的顺序不确定。
f(i++, i++)的结果依赖编译器。 i = i++在 C++17 前是未定义行为,C++17 起有确定顺序。 但还是别这么写。- 重载运算符的值类别看返回类型。 内置
+是 prvalue,重载的operator+可以返回T&。 - 重载
operator&&会失去短路。 它变成函数调用,两个操作数都要求值。 vector<bool>的operator[]返回代理对象。auto b = v[0]得到的不是bool。
33. 怎么练习,靠方法
值类别和表达式规则看起来很多,但真正长期用得上的只有三条主线。
主线一:先看树,再看节点
不要一上来就盯着某个运算符。先根据优先级和结合性,把表达式拆成树,再从叶子往根推。
cpp
*p++ = *q++;
先拆成 *(p++) = *(q++),再逐个节点看类型和值类别。
主线二:类型和值类别分开看
类型回答"它是什么",值类别回答"它能不能被搬走"。
cpp
std::string&& r = std::move(s);
r 的声明类型是 std::string&&,但表达式 r 是 lvalue,表达式类型是 std::string。类型和值类别不是一回事。
主线三:有副作用就拆开写
一行里出现两个以上的修改,或者一个修改加一个读取,最好拆成多条语句。
cpp
// 不容易读
a[i] = i++;
// 容易读(按 C++17 的顺序:先取出旧值并让 i 加一,再写 a[i])
int old_value = i++;
a[i] = old_value;
拆分之后,求值顺序、副作用、临时对象生命周期都变得清楚。
一个简单的练习方法
每天从项目里挑十个表达式,按四问法过一遍:
- 树长什么样?
- 每个节点的类型是什么?
- 每个节点的值类别是什么?
- 有没有副作用?临时对象活多久?
坚持一段时间,你会发现自己不再需要查表,看到表达式就能条件反射地拆开。
34. 练习题
34.1 判断类型和值类别
cpp
int x = 1;
int& lr = x;
int&& rr = 2;
int* p = &x;
struct S { int n; };
S s{1};
判断下列表达式的类型和值类别:
xlrrrstd::move(rr)*p&xs.nS{2}.nx = 5x++++xx + 1p*p + 1std::move(*p)
答案:
int,lvalue。int,lvalue。lr的声明类型是int&。int,lvalue。rr的声明类型是int&&,但表达式类型去掉引用,值类别是左值。int,xvalue。std::move的返回类型是int&&。int,lvalue。int*,prvalue。int,lvalue。int,xvalue。int,lvalue。int,prvalue。int,lvalue。int,prvalue。int*,lvalue。int,prvalue。int,xvalue。
34.2 判断解析方式
把下列表达式加上括号,明确解析顺序:
*p++++*p*++pa = b = ca ? b : c = da = b ? c : da, b = cstd::cout << a << ba + b * ca < b && c > d
答案:
*(p++)++(*p)*(++p)a = (b = c)a ? b : (c = d)a = (b ? c : d)a, (b = c)。逗号的优先级最低,所以a, b = c先算赋值,再算逗号;整个表达式是逗号表达式,结果是b = c。(std::cout << a) << ba + (b * c)(a < b) && (c > d)
34.3 找出未定义行为
cpp
int i = 0;
int a[10];
i = i++; // 1
a[i] = i++; // 2
f(i++, i++); // 3
i = ++i + i++; // 4
std::cout << i << i++; // 5
按 C++17 规则判断:
- C++17 前未定义,C++17 起有确定顺序。
- C++17 前未定义,C++17 起有确定顺序。
- C++17 前未定义,C++17 起顺序不确定但不是未定义。
- 仍然是未定义行为:
++i和i++无序,且都修改i。 - C++17 前未定义;C++17 起有确定顺序(
<<的左操作数先于右操作数)。
这些例子都不建议写进实际代码。即使标准规定了顺序,读代码的人也不一定记得。
34.4 找出悬垂引用
cpp
const std::string& f1() {
return std::string("hello"); // 1
}
const std::string& f2(const std::string& s) {
return s;
}
const std::string& r1 = f1(); // 2
const std::string& r2 = f2(std::string("hi")); // 3
std::string&& r3 = std::move(std::string("hi")); // 4
const int& r4 = std::max(1, 2); // 5
答案:
- 返回局部临时对象的引用,悬垂。
r1悬垂。r2悬垂:临时实参只活到完整表达式结束。r3悬垂:std::move返回 xvalue,不延长生命周期。r4悬垂:std::max返回引用,绑定到临时实参。
34.5 解释输出
cpp
#include <iostream>
int main() {
int x = 1;
int y = (x++, x + 1);
std::cout << x << ' ' << y << '\n';
}
答案:2 3。逗号表达式先执行 x++,x 变成 2,再计算 x + 1,得到 3。
34.6 解释输出
cpp
#include <iostream>
struct S {
S() { std::cout << "ctor\n"; }
S(const S&) { std::cout << "copy\n"; }
S(S&&) noexcept { std::cout << "move\n"; }
};
S make() {
return S{};
}
int main() {
S a = make();
S b = std::move(a);
S c = a;
}
答案(C++17 起):
text
ctor
move
copy
make() 返回 prvalue,C++17 保证省略,所以只有一次 ctor。S b = std::move(a); 调用移动构造,输出 move。S c = a; 调用拷贝构造,输出 copy。
34.7 解释 *p++ = *q++;
答案:
- 解析为
*(p++) = *(q++)。 p++和q++都是 prvalue,返回旧指针。*(p++)和*(q++)都是 lvalue。- 赋值把
*q的旧值写到*p的旧位置,然后p、q各加一。 - C++17 起,赋值右边先于左边求值。
- C++17 之前,如果
p和q指向同一对象,读和写无序,属于未定义行为;C++17 起有确定顺序,但这种写法仍然不建议。
35. 参考资料
- cppreference:Expressions
en.cppreference.com/w/cpp/langu... - cppreference:Value categories
en.cppreference.com/w/cpp/langu... - cppreference:Order of evaluation
en.cppreference.com/w/cpp/langu... - cppreference:Operator precedence
en.cppreference.com/w/cpp/langu... - cppreference:Member access operators
en.cppreference.com/w/cpp/langu... - cppreference:Other operators(条件、逗号、sizeof、typeid 等)
en.cppreference.com/w/cpp/langu... - cppreference:Implicit conversions
en.cppreference.com/w/cpp/langu... - cppreference:Copy elision
en.cppreference.com/w/cpp/langu... - cppreference:
decltype
en.cppreference.com/w/cpp/langu... - Microsoft Learn:Semantics of expressions(2018-11-18)
learn.microsoft.com/en-us/cpp/c... - P0145R3:Refining Expression Evaluation Order for Idiomatic C++
www.open-std.org/jtc1/sc22/w... - P1825R0:Merged wording for P0527R1 and P1155R3
www.open-std.org/jtc1/sc22/w... - Wikipedia:Most vexing parse
en.wikipedia.org/wiki/Most_v... - C++ Core Guidelines
isocpp.github.io/CppCoreGuid...