C++ 表达式怎么读:从一行代码到类型、值类别和生命周期

C++ 表达式怎么读:从一行代码到类型、值类别和生命周期

写在前面

先看一行代码:

cpp 复制代码
int a[10];
int* p = a;
int* q = a + 1;

*p++ = *q++;

这一行里藏着好几个问题:

  • *p++ 到底是 (*p)++ 还是 *(p++)?
  • p++ 和 *p 分别是什么类型、什么值类别?
  • 赋值的左边和右边,谁先算?
  • p 和 q 什么时候加一?
  • 如果 p 和 q 指向同一块内存,结果还一样吗?

上一篇《C++ 左值与右值》列过一张表达式值类别的表。很多人看完表,遇到新的表达式还是会判断错。问题通常不在看过多少遍,而在于没有一套固定的拆解顺序:先看什么、后看什么、看到什么就该得出什么结论。

这篇文章想解决的就是这件事。它不要求你背一张大表,而是给你一套可以重复使用的方法。读完以后,遇到一个没见过的表达式,你至少知道从哪儿下手。

整套方法可以压缩成四个问题:

  1. 这棵表达式树长什么样? 谁和谁先结合?
  2. 每个节点的类型是什么? 这决定了能做哪些运算、会发生哪些转换。
  3. 每个节点的值类别是什么? 这决定了能绑定什么引用、会不会被移动。
  4. 有没有副作用?谁先谁后?临时对象活多久?

下面按这四问展开。

目录

  • 第一部分 先把表达式看成一棵树
    *
    1. 表达式是什么
      1. 表达式和语句不是一回事
      1. 优先级和结合性:树怎么长
      1. 读表达式的四问法
      1. 一个完整的拆解示例
  • 第二部分 一类一类认识表达式
      1. 名字
      1. 字面量
      1. 一元表达式
      1. 二元表达式
      1. 成员访问
      1. 下标
      1. 函数调用
      1. 条件表达式
      1. 逗号表达式
      1. 赋值表达式
      1. 强制转换
      1. sizeof、alignof、decltype、typeid、noexcept
      1. new、delete、throw
      1. lambda 表达式
      1. C++17/20/23 的新表达式
  • 第三部分 类型、值类别、转换和求值
      1. 类型怎么定
      1. 值类别怎么定
      1. 隐式转换
      1. 重载决议
      1. 临时对象和生命周期
      1. 求值顺序和副作用
      1. 重载运算符和代理对象
      1. 表达式模板和惰性求值
  • 第四部分 上一篇文章里的表达式逐个拆
      1. 速查表
      1. 容易看错的十几个表达式
      1. 一套通用的拆解流程
      1. 二十个容易误判的案例
      1. 怎么练习,靠方法
      1. 练习题
      1. 参考资料

第一部分 先把表达式看成一棵树

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 的结果类型分两种情况:

  1. 如果 expr 是没有括号的标识表达式,或者没有括号的类成员访问,结果是这个表达式命名的实体的声明类型。
  2. 否则,根据表达式的值类别:
    • xvalue:T&&
    • lvalue:T&
    • prvalue:T
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 两个问题

如果不确定,问自己两个问题:

  1. 这个表达式有没有身份? 能不能判断它和另一个表达式指的是不是同一个对象?
  2. 这个对象的资源能不能被搬走? 它是不是马上就要销毁了?
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();

拆解:

  1. 树:auto x = (f(std::move(v[i])) + g());
  2. 类型:v[i] 是 lvalue,表达式类型 T;std::move(v[i]) 是 xvalue,表达式类型 T(返回类型是 T&&);f(...) 的类型看 f 的返回类型去掉引用;g() 同理;+ 的结果是共同类型。
  3. 值类别:v[i] 是 lvalue;std::move(v[i]) 是 xvalue;f(...) 看返回类型;g() 看返回类型;+ 通常是 prvalue。
  4. 副作用:f 可能移动 v[i];g 可能有副作用;+ 的操作数顺序未指定(C++17 仍如此)。
  5. 生命周期:v[i] 必须在 f 调用期间活着;如果 f 保存了引用,后面可能悬垂。

32. 二十个容易误判的案例

下面这些表达式,很多人第一次都会判断错。每个给一句解释。

  1. int&& r = 42; r 是 lvalue。 有名字的右值引用变量是左值。
  2. std::move(const_obj) 不会移动。 它返回 const T&&,移动构造绑不上,会退化成拷贝。
  3. return std::move(local); 会阻止 NRVO。 直接写 return local; 更好。
  4. a = b 是 lvalue。 内置赋值返回左操作数的引用。
  5. x++ 是 prvalue,++x 是 lvalue。 后置返回旧值,前置返回对象本身。
  6. "hello" 是 lvalue。 字符串字面量是 const char[N],有固定地址。
  7. &x 是 prvalue。 取出来的地址是一个临时值。
  8. S{}.m 是 xvalue。 临时对象的非引用数据成员是 xvalue。
  9. a, b 的值类别看 b。 逗号表达式取右操作数。
  10. cond ? a : b 的值类别看两个分支。 两者同为 lvalue 才是 lvalue。
  11. typeid(x) 是 lvalue。 它的表达式类型是 const std::type_info,返回的是类型信息的引用。
  12. this 是 prvalue。 它是一个指针值;*this 才是对象。
  13. sizeof(x++) 不会让 x 加一。 操作数不求值。
  14. decltype(x) 和 decltype((x)) 可能不同。 前者看声明类型,后者看值类别。
  15. auto 会丢掉引用和顶层 const。 需要保留时用 auto&、auto&& 或 decltype(auto)。
  16. 函数实参的顺序不确定。 f(i++, i++) 的结果依赖编译器。
  17. i = i++ 在 C++17 前是未定义行为,C++17 起有确定顺序。 但还是别这么写。
  18. 重载运算符的值类别看返回类型。 内置 + 是 prvalue,重载的 operator+ 可以返回 T&。
  19. 重载 operator&& 会失去短路。 它变成函数调用,两个操作数都要求值。
  20. 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;

拆分之后,求值顺序、副作用、临时对象生命周期都变得清楚。

一个简单的练习方法

每天从项目里挑十个表达式,按四问法过一遍:

  1. 树长什么样?
  2. 每个节点的类型是什么?
  3. 每个节点的值类别是什么?
  4. 有没有副作用?临时对象活多久?

坚持一段时间,你会发现自己不再需要查表,看到表达式就能条件反射地拆开。

34. 练习题

34.1 判断类型和值类别

cpp 复制代码
int x = 1;
int& lr = x;
int&& rr = 2;
int* p = &x;

struct S { int n; };
S s{1};

判断下列表达式的类型和值类别:

  1. x
  2. lr
  3. rr
  4. std::move(rr)
  5. *p
  6. &x
  7. s.n
  8. S{2}.n
  9. x = 5
  10. x++
  11. ++x
  12. x + 1
  13. p
  14. *p + 1
  15. std::move(*p)

答案:

  1. int,lvalue。
  2. int,lvalue。lr 的声明类型是 int&。
  3. int,lvalue。rr 的声明类型是 int&&,但表达式类型去掉引用,值类别是左值。
  4. int,xvalue。std::move 的返回类型是 int&&。
  5. int,lvalue。
  6. int*,prvalue。
  7. int,lvalue。
  8. int,xvalue。
  9. int,lvalue。
  10. int,prvalue。
  11. int,lvalue。
  12. int,prvalue。
  13. int*,lvalue。
  14. int,prvalue。
  15. int,xvalue。

34.2 判断解析方式

把下列表达式加上括号,明确解析顺序:

  1. *p++
  2. ++*p
  3. *++p
  4. a = b = c
  5. a ? b : c = d
  6. a = b ? c : d
  7. a, b = c
  8. std::cout << a << b
  9. a + b * c
  10. a < b && c > d

答案:

  1. *(p++)
  2. ++(*p)
  3. *(++p)
  4. a = (b = c)
  5. a ? b : (c = d)
  6. a = (b ? c : d)
  7. a, (b = c)。逗号的优先级最低,所以 a, b = c 先算赋值,再算逗号;整个表达式是逗号表达式,结果是 b = c。
  8. (std::cout << a) << b
  9. a + (b * c)
  10. (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 规则判断:

  1. C++17 前未定义,C++17 起有确定顺序。
  2. C++17 前未定义,C++17 起有确定顺序。
  3. C++17 前未定义,C++17 起顺序不确定但不是未定义。
  4. 仍然是未定义行为:++i 和 i++ 无序,且都修改 i。
  5. 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

答案:

  1. 返回局部临时对象的引用,悬垂。
  2. r1 悬垂。
  3. r2 悬垂:临时实参只活到完整表达式结束。
  4. r3 悬垂:std::move 返回 xvalue,不延长生命周期。
  5. 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. 参考资料

相关推荐
kyle~3 小时前
因子图优化(Factor Graph Optimization)
c++·算法·机器人·传感器
geats人山人海4 小时前
现代c++4.1
java·开发语言·c++
lunar_coder6 小时前
【算法】前缀和:把 O(n) 的重复劳动变成 O(1) 的一次查询
c++·算法
青少儿编程课堂6 小时前
第十八届蓝桥杯青少组图形化 + 全国青少年信息素养大赛 + 电子学会图形化考级:校园三消乐大挑战解析
c++·python·算法·bfs·信息学竞赛
青少儿编程课堂6 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:网格连通块与岛屿数量(DFS+BFS双解)
c++·python·算法·bfs·信息学竞赛
码客-ygluu15 小时前
X3 LUA 异步分布式微服务集群框架
c++·架构·lua
九英里路18 小时前
protobuf快速上手
网络·c++·中间件·json·谷歌·序列化·protobuf
纪念 22918 小时前
C++ 算法基础 (差分)
开发语言·c++·算法
ShineWinsu1 天前
对于Qt:QTreeWidget常见属性以及QTreeWidgetItem类的解析
开发语言·c++·qt·gui·客户端·多叉树·qtreewidget