C++的复杂,C是原罪:从值类别说开去

62d4781e81ae3e7cdce065aa75d89120.png

69d3c4fd354636d35ca329c4879440a0.gif

👉导读

我们知道 C++ 的值类别包括左值、右值、纯右值、广义左值、将亡值。可 C++ 到底是经历了什么才硬要把这件事情搞得如此复杂呢?我们不妨从 C 语言、汇编和 C++ 设计发展的角度来分析一下这个问题~

👉目录

0 写在前面

1 从 C 语言开始讲起

2 考虑上构造和析构函数会怎么样

3 左值、纯右值与将亡值

4 xvalue 取址问题与 C++ 引用

5 常引用与右值

6 再来研究一次返回局部变量

7 右值引用与复制省略

8 移动语义

9 Redis 分布锁存在的问题

10 总结

2022年,C++强势涨幅反弹,成功挤下 Java 杀入 TIOBE 编程语言排行榜前三位置,并在年底评选中击败了 C 和 Python,被评为 2022 TIOBE 年度编程语言。

26aaef4550766f35404da15d58893cf3.png

随着 C++20 的发布,其出色的性能和不断发布的具有有趣功能的新语言标准,让 C++再次崛起。但对很多研发而言,C++的学习成本依旧很高,比如本文将要聊到的值类别问题。

0

写在前面

相信大家在写 C++ 的时候一定会经常讨论到「左值」「右值」「将亡值」等等的概念,在笔者的其他系列文章中也反复提及这几个概念,再加上一些「右值引用」「移动语义」等等这些概念的出现,说一点都不晕那一定是骗人的。

很多人都在吐槽 C++,为什么要设计的这样复杂?就一个程序语言,还能搞出这么多值类别来?(话说可能自然语言都不见得有这么复杂吧……),那么这篇我们就来详细研究一下,为什么要专门定义这样的值类型,以及在这个过程中笔者自己的思考。

=====提示================

中间篇幅得出的一些「临时结论」只是依据现有现象总结出来的,可能会跟最终结论有冲突,如果有读者有疑问,请先向后看,后面可能会颠覆这个临时结论

========================

不得不吐槽一下,笔者认为,C++ 之所以复杂,C 语言是原罪。因为 C++ 一开始设计的目的,就是为给 C 来进行语法扩充的。因此,C++ 的设计方式和其他语言会有一些不同。

一般设计一门程序语言,应该是先设计一套语言体系,我希望这个语言提供哪些语法、哪些功能。之后再去根据这套理论体系来设计编译器,也就是说对于每一种语法如何解析,如何进行汇编。

但 C++ 是不同的,因为在设计 C++ 的语言体系的时候,就已经有完整的 C 语言了。因此,C++ 的语言体系其实是在 C 的语言体系、编译器实现以及标准库等这些之上,又重新建立的。所以说 C++ 从设计之初,就决定了它没办法甩开 C 的缺陷。很多问题都是为了解决一个问题又不得不引入另一个问题,不断「找补」导致的。今天要细说的 C++ 值类别(Value Category)就是其中非常有代表性的一个。

所以要想解释清为什么会有这些概念,我们就要从 C 语言开始,去猜测和体会 C++ 设计者的初衷,遇到的问题以及「找补」的手段,这样才能真正理解这些概念是如何诞生的。

1

从 C 语言开始讲起

在 C 语言当中其实并没有什么「左右值」之类的概念,单从值的角度来说 C 语言仅仅在意的是「可变量」和「不可变量」。但 C 更关心的是,数据存在哪里,首先是内存还是寄存器?为了区分「内存变量」还是「寄存器变量」,从而诞生了 register 和 auto 关键字(用 register 修饰的要放在寄存器中,auto 修饰的由编译器来决定放在哪里,没有修饰符的要放在内存中)。

之后,即便是内存也要再继续细致划分,C 把内存划分为4大区域,分别是全局区、静态区、堆区和栈区。而「栈区」主要依赖于函数(我觉得这个地方翻译成「存储过程」可能更合适),在 C 语言的视角来看,每一个程序就是一个过程(主函数),而这个过程执行的途中,会有很多子过程(其他函数),一个程序就是若干过程嵌套拼接和组合的结果。这其实也就是 C 语言「面向过程」的原因,因为它就是这样来设计的。从 C 语言衍生出的 C++、OC、Go 等其实都没有逃过这个设计框架。以 OC 为例,别看 OC 是面向对象的,但它仍然可以过程式开发,它的程序入口也是主函数,这个切入点来看它还是面相过程的,只是在执行这个过程中,衍生出了面向对象的操作。(这里就不详细展开了。)

那么以 C 语言的视角来看,一个函数其实就是一个过程,所以这个过程应该就需要相对独立的数据区域,仅仅在这个过程中生效,当过程结束,那这些数据也就不需要了。这就是函数的栈区的目的,我们把在栈区中的变量称作「局部变量」。

虽然栈区把不同过程之间的数据隔离开了,但是我们在过程的执行之间肯定是要有一些数据传递的,体现在 C 语法上就是函数的参数和返回值。正常来说,一个函数的调用过程是:

  1. 划分一个栈区用于当前函数的执行(这里其实只要确定一个栈底就好了);

  2. 把函数需要的所有数据入栈;

  3. 执行函数体(也就是指令组了);

  4. 把函数的结果返回出去;

  5. 栈区作废,可以重复利用。

在早期版本的 C 语言(C89)中,每个函数中需要的局部变量都是要在函数头定义全的,也就是说函数体中是不能再单独定义变量的,主要就是为了让编译器能够划分好内存空间给每一个局部变量。但后来在 C99 标准里这个要求被放开了,但本质上来说原理是没有变的,编译器会根据局部变量定义的顺序来进行空间的分配。

要理解这一点,我们直接从汇编代码上来看是最直观的。首先给出一个用于验证的 C 代码:

void Demo() {
  int a = 0;
  long b = 1;
  short c = 2;
}

将其转换为 AMD64 汇编是这样的:

Demo:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 0
        mov     QWORD PTR [rbp-16], 1
        mov     WORD PTR [rbp-18], 2
        nop
        pop     rbp
        ret

rbp 寄存器中存放的就是栈底的地址,我们可以看到,rbp-4 的位置放了变量 a,因为 a 是 int 类型的,所以占用4个字节,也就是从[rbp]到[rbp-4]的位置都是变量 a(这里注意里面是减法哈,按照小端序的话低字节是高位),然后按照我们定义变量的顺序来排布的(中间预留4字节是为了字节对齐)。

那如果函数有参数呢?会放在哪里?比如:

void Demo(int in1, char in2) {
  int a = 0;
  long b = 1;
  short c = 2;
}

会转换为:

Demo:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-36], edi
        mov     eax, esi
        mov     BYTE PTR [rbp-40], al
        mov     DWORD PTR [rbp-4], 0
        mov     QWORD PTR [rbp-16], 1
        mov     WORD PTR [rbp-18], 2
        nop
        pop     rbp
        ret

可以看出来,函数参数也是作为一种局部变量来使用的,我们可以看到这里处理参数都是直接处理内存的,也就是说在函数调用的时候,就是直接把拿着实参的值,在函数的栈区创建了一个局部变量。所以函数参数在函数内部也是作为局部变量来对待的。

那如果函数有返回值呢?请看下面实例:

int Demo() {
  return 5;
}

会转义为:

Demo:
        push    rbp
        mov     rbp, rsp
        mov     eax, 5
        pop     rbp
        ret

也就是说,返回值会直接写入寄存器,这样外部如果需要使用函数返回值的话,就直接从寄存器中取就好了。

所以,上面的例子主要是想表明,C 语言的设计对于编译器来说是相当友好的,从某种程度上来说,就是在给汇编语法做一个语法糖。数据的传递都是按照硬件的处理逻辑来布局的。请大家先记住这个函数之间传值的方式,参数就是普通的局部变量;返回的时候是把返回值放到寄存器,调用方会再从寄存器中拿。这个过程我们可以写一个更加直观的例子:

int Demo1(int a) {
  return 5;
}


void Demo2() {
    int a = Demo1(2);
}

汇编后是:

Demo1:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     eax, 5
        pop     rbp
        ret
Demo2:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     edi, 2
        call    Demo1
        mov     DWORD PTR [rbp-4], eax
        nop
        leave
        ret

这就非常说明问题了,函数传参时,因为已经构建了被调函数的栈空间,所以可以直接变量复制,但对于返回值,这是本篇的第一个重点!!「函数返回值是放在寄存器中传递出去的」。

寄存器传递数据固然方便,但寄存器长度是有上限的,如果需要传递的数据超过了寄存器的长度怎么办?

struct Test {
  long a, b;
};


struct Test Demo() {
  struct Test t = {1, 2};
  return t;
}

汇编后是:

Demo:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-16], 1
        mov     QWORD PTR [rbp-8], 2
        mov     rax, QWORD PTR [rbp-16]
        mov     rdx, QWORD PTR [rbp-8]
        pop     rbp
        ret

尴尬~~编译器竟然用了2个寄存器来返回数据……这太不给面子了,那我们就再狠一点,搞再长一点:

struct Test {
  long a, b, c;
};


struct Test Demo() {
  struct Test t = {1, 2, 3};
  return t;
}

当结构体的长度再大一点的时候,情况就发生改变了:

Demo:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-40], rdi
        mov     QWORD PTR [rbp-32], 1
        mov     QWORD PTR [rbp-24], 2
        mov     QWORD PTR [rbp-16], 3
        mov     rcx, QWORD PTR [rbp-40]
        mov     rax, QWORD PTR [rbp-32]
        mov     rdx, QWORD PTR [rbp-24]
        mov     QWORD PTR [rcx], rax
        mov     QWORD PTR [rcx+8], rdx
        mov     rax, QWORD PTR [rbp-16]
        mov     QWORD PTR [rcx+16], rax
        mov     rax, QWORD PTR [rbp-40]
        pop     rbp
        ret

我们能看到,这里做的事情很有趣,[rbp-40]~[rpb-16]这24个字节是局部变量 t,函数执行后被写在了[rdi]~[rdi+24]这24个字节的空间的位置,而最后寄存器中存放的是 rdi 的值(汇报指令有点绕,受限于 AMD64 汇编语法的限制,不同种类寄存器之间不能直接赋值,所以它先搞到了[rbp-40]的内存位置,然后又写到了 rcx 寄存器中,所以后面的[rcx+8]其实就是[rdi+8],最后 rax 中其实放的也是一开始的 rdi 的值)。那这个 rdi 寄存器的值是谁给的呢?我们加上调用代码来观察:

struct Test {
  long a, b, c;
};


struct Test Demo1() {
  struct Test t = {1, 2, 3};
  return t;
}


void Demo2() {
  struct Test t = Demo1();
}

汇编成:

Demo1:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-40], rdi
        mov     QWORD PTR [rbp-32], 1
        mov     QWORD PTR [rbp-24], 2
        mov     QWORD PTR [rbp-16], 3
        mov     rcx, QWORD PTR [rbp-40]
        mov     rax, QWORD PTR [rbp-32]
        mov     rdx, QWORD PTR [rbp-24]
        mov     QWORD PTR [rcx], rax
        mov     QWORD PTR [rcx+8], rdx
        mov     rax, QWORD PTR [rbp-16]
        mov     QWORD PTR [rcx+16], rax
        mov     rax, QWORD PTR [rbp-40]
        pop     rbp
        ret
Demo2:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        lea     rax, [rbp-32]
        mov     rdi, rax
        mov     eax, 0
        call    Demo1
        nop
        leave
        ret

也就是说,在这种场景下,调用 Demo1 之前,rdi 写的就已经是 Demo2 中 t 的地址了。编译器其实是把「返回值」变成了「出参」,直接拿着「将要接受返回值的变量地址」进到函数里面来处理了。这是本篇的第二个重点!!「函数返回值会被转换为出参,内部直接操作外部栈空间」。

但假如,我们要的并不是「返回值的全部」,而是「返回值的一部分」呢?比如说:

struct Test {
  long a, b, c;
};


struct Test Demo1() {
  struct Test t = {1, 2, 3};
  return t;
}


void Demo2() {
  long a = Demo1().a; // 只要其中的一个成员
}

那么这个时候会汇编成:

Demo1:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-40], rdi
        mov     QWORD PTR [rbp-32], 1
        mov     QWORD PTR [rbp-24], 2
        mov     QWORD PTR [rbp-16], 3
        mov     rcx, QWORD PTR [rbp-40]
        mov     rax, QWORD PTR [rbp-32]
        mov     rdx, QWORD PTR [rbp-24]
        mov     QWORD PTR [rcx], rax
        mov     QWORD PTR [rcx+8], rdx
        mov     rax, QWORD PTR [rbp-16]
        mov     QWORD PTR [rcx+16], rax
        mov     rax, QWORD PTR [rbp-40]
        pop     rbp
        ret
Demo2:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        lea     rax, [rbp-32]
        mov     rdi, rax
        mov     eax, 0
        call    Demo1
        mov     rax, QWORD PTR [rbp-32]
        mov     QWORD PTR [rbp-8], rax
        nop
        leave
        ret

我们发现,虽然在 Demo2 中没有刚才那样完整的结构体变量 t,但编译器还是会分配一片用于保存返回值的空间,把这个空间的地址写在 rdi 中,然后拿着这个空间到 Demo1 中来操作。等 Demo1 函数执行完,再根据需要,把这片空间中的数据复制给局部变量 a。

换句话说,编译器其实是创建了一个匿名的结构体变量(我们姑且叫它tmp),所以上面的代码其实等价于:

void Demo2() {
  struct Test tmp = Demo1(); // 注意这个变量其实是匿名的
  int a = tmp.a;
}
   1.1 小结

总结上面所说,对于一个函数的返回值:

  1. 如果能在一个寄存器存下,就会存到寄存器中。

  2. 如果在一个寄存器存不下,就会考虑拆分到多个寄存器中。

  3. 如果多个可用的寄存器都存不下,就会考虑直接用内存来存放,在调用函数之前先开放一片内存空间用于储存返回值,然后函数内部直接使用这片空间。

  4. 如果调用方直接接收函数返回值,那么就会直接把这片空间标记给这个变量。

  5. 如果调用方只使用返回值的一部分,那么这片空间就会成为一个匿名的空间存在(只有地址,但没有变量名)。

这一套体系在 C 语言中其实并没有太多问题,但有了 C++ 的拓展以后,就不一样了。

2

考虑上构造和析构函数会怎么样

C++ 在 C 的基础上,为结构体添加了构造函数和析构函数,为了能「屏蔽抽象内部的细节」,将构造和析构函数与变量的生命周期进行了绑定。在创建变量时会强制调用构造函数,而在变量释放时会强制调用析构函数。

如果是正常在一个代码块内,这件事自然是无可厚非的,我们也可以简单来验证一下:

struct Test {
  Test() {}
  ~Test() {}
};


void Demo() {
  Test t;
}

汇编成:

Test::Test() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::~Test() [base object destructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Demo():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        leave
        ret

注意 C++ 由于支持了函数重载,因此函数签名里会带上参数类型,所以这里的函数名都比 C 语言直接汇编出来的多一个括号。

那如果一个自定义了构造和析构的类型做函数返回值的话会怎么样?比如:

struct Test {
  Test() {}
  ~Test() {}
};


Test Demo1() {
  Test t;
  return t;
}


void Demo2() {
  Test t = Demo1();
}

这里我们给编译器加上 -fno-elide-constructors 参数来关闭返回值优化,这样能看到语言设计的本质,汇编后是:

Test::Test() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::~Test() [base object destructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::Test(Test const&) [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        mov     QWORD PTR [rbp-16], rsi
        nop
        pop     rbp
        ret
Demo1():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     QWORD PTR [rbp-24], rdi
        lea     rax, [rbp-1]
        mov     rdi, rax                        ;注意这里rdi发生了改变!
        call    Test::Test() [complete object constructor]
        lea     rdx, [rbp-1]
        mov     rax, QWORD PTR [rbp-24]
        mov     rsi, rdx
        mov     rdi, rax
        call    Test::Test(Test const&) [complete object constructor]
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        nop
        mov     rax, QWORD PTR [rbp-24]
        leave
        ret
Demo2():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Demo1()
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        leave
        ret

这次代码就非常有意思了,首先,编译器自动生成了一个拷贝构造函数 Test::Test(const Test &)。接下来做的事情跟纯 C 语言结构体就有区别了,在 Demo2 中,由于我们仍然是用变量直接接收了函数返回值,所以它同样还是直接把t的地址,写入了 rdi,这里行为和之前是一样的。但是在 Demo1 中,rdi 的值写入了 rbp-24 的位置,但后面调用构造函数的时候传入的是 rbp-1,所以说明这个位置才是 Demo1 中的 t 实际的位置,等待构造函数调用完之后,又调用了一次拷贝构造,这时传入的才是 rbp-24,也就是外部传进来保存函数返回值的地址。

也就是说,由于构造函数和析构函数跟变量生命周期相绑定了,因此这时并不能直接把「函数返回值转出参」了,而是先生成一个局部变量,然后通过拷贝构造函数来构造「返回值」,再析构这个局部变量。所以整个过程会多一次拷贝和析构的过程。

这么做,是为了保证对象的行为自闭环,但只有当析构函数和拷贝构造函数是非默认行为的时候,这样做才有意义,如果真的就是 C 类型的结构体,那就没这个必要了,按照原来 C 的方式来编译即可。因此 C++ 在这里强行定义了「平凡(trivial)」类型的概念,主要就是为了指导编译器,对于平凡类型,直接按照C的方式来编译,而对于非平凡的类型,要调用构造和析构函数,因此必须按照新的方式来处理(刚才例子那样的方式)。

那么这个时候再考虑一点,如果我们还是只使用返回值的一部分呢?比如说:

struct Test {
  Test() {}
  ~Test() {}
  int a;
};


Test Demo1() {
  Test t;
  return t;
}


void Demo2() {
  int a = Demo1().a;
}

结果非常有趣:

Test::Test() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::~Test() [base object destructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::Test(Test const&) [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        mov     QWORD PTR [rbp-16], rsi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdx, QWORD PTR [rbp-16]
        mov     edx, DWORD PTR [rdx]
        mov     DWORD PTR [rax], edx
        nop
        pop     rbp
        ret
Demo1():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     QWORD PTR [rbp-24], rdi
        lea     rax, [rbp-4]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]
        lea     rdx, [rbp-4]
        mov     rax, QWORD PTR [rbp-24]
        mov     rsi, rdx
        mov     rdi, rax
        call    Test::Test(Test const&) [complete object constructor]
        lea     rax, [rbp-4]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        nop
        mov     rax, QWORD PTR [rbp-24]
        leave
        ret
Demo2():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-8]
        mov     rdi, rax
        call    Demo1()
        mov     eax, DWORD PTR [rbp-8]
        mov     DWORD PTR [rbp-4], eax            ;这里是给局部变量a赋值
        lea     rax, [rbp-8]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        nop
        leave
        ret

这里仍然会分配一个匿名的空间用于接收返回值,然后再从这个匿名空间中取值复制给局部变量 a。从上面的代码能看出,匿名空间在 rbp-8 的位置,局部变量 a 在 rbp-4 的位置。但这里非常有意思的是,在给局部变量赋值后,立刻对匿名空间做了一次析构(所以它把 rbp-8 写到了 rdi 中,然后 call 了析构函数)。这是本篇的第三个重点!!「如果用匿名空间接收函数返回值的话,在处理完函数调用语句后,匿名空间将会被析构」。

3

左值、纯右值与将亡值

讲了这么多,总算能回到主线上来了,先来归纳一下前文出现的3个重点:

  1. 函数返回值是放在寄存器中传递出去的;

  2. 函数返回值会被转换为出参,内部直接操作外部栈空间;

  3. 如果用匿名空间接收函数返回值的话,在处理完函数调用语句后,匿名空间将会被析构。

其实对应了函数返回数据的3种处理方式:

  1. 直接存在寄存器里;

  2. 直接操作用于接收返回值的变量(如果是平凡的,直接操作;如果是非平凡的,先操作好一个局部变量,然后再拷贝过来);

  3. 先放在一个临时的内存空间中,使用完后再析构掉。

C++ 按照这个特征来划分了 prvalue 和 xvalue。(注意,英语中所有以"ex"开头的单词,如果缩写的话会缩写为"x"而不是"e",就比如说"Extreme Dynamic Range"缩写是"XDR"而不是"EDR"; "Extensible Markup Language"缩写为"XML"而不是"EML"。)

所谓 prvalue,翻译为“纯右值”,表示的就是第1种,也就是用寄存器来保存的情况,或者就是字面常量。举例来说,1这就是个纯右值,它在汇编中就是一个单纯的常数。然后就是返回值通过寄存器来进行的这种情况。对于 C/C++ 这种语言来说,我们可以尽情操作内存,但没法染指寄存器,所以在它看来,寄存器中的数就跟一个常数值一样,只能感知到它的值而已,不能去操控,不能去改变。换一种说法,prvalue 就是「没有内存实体」的值,常数没有内存实体,寄存器中的数据也没有内存实体。所以 prvalue 没有地址。

而对于第2种的情况,「返回值」的这件事情其实是不存在的,只是语义上的概念。实际就是操作了一个调用方的栈空间。因此,这种情况就等价于普通的变量,它是一个 lvalue,它是实实在在可控的,有内存实体,程序可以操作。

对于第3种的情况,「返回值」被保存在一个匿名的内存空间中,它在完成某一个动作之后就失效了(非平凡析构类型的就会调用析构函数)。比如用上一节的例子来说,从 Demo1 函数的返回值(匿名空间)获取了成员 a 交给了局部变量,然后,这个匿名空间就失效了,所以调用了~Demo 析构函数。我们把这种值称为 xvalue(将亡值),xvalue 也有内存实体。

以目前得到的信息来说,xvalue 和 lvalue 的区别就在于生命周期。在C++ 中生命周期比在 C 中更加重要,在 C 中讨论生命周期其实仅仅在于初始化和赋值的问题(比如说局部 static 变量的问题),但到了 C++ 中,生命周期会直接决定了构造和析构函数的调用,因此更加重要。xvalue 会在当前语句结束时立刻析构,而 lvalue 会在所属代码块结束时再析构。所以针对于 xvalue 的情况,在 C 中并不明显,反正我们是从匿名的内存空间读取出数据来,这件事情就结束了;但 C++ 中就会涉及析构函数的问题,这就是 xvalue 在 C++ 中非常特殊的原因。

4

xvalue 取址问题与 C++ 引用

对于 prvalue 来说,它是纯「值」或「寄存器值」,因此不能取地址,这件事无可厚非。但对于 xvalue 来说呢?xvalue 有内存实体,但为什么也不能取地址呢?

原因就是在于,原本 C 语言在设计这个部分的时候,函数返回值究竟要写到一个局部变量里,还是要写到一个匿名的内存空间里这件事是不能仅通过一个函数调用语句来判断,而是要通过上下文。也就是说,struct Test t = Demo1();的时候,t 本身的地址就是返回值地址,此时返回值是 lvalue(因为 t 就是 lvalue);而如果是 int ta = Demo1().a;的时候,返回值的地址是一个匿名的空间,此时返回值就是 xvalue,而这里的 ta 就不再是返回值的地址。所以,如果你什么都不给,单纯给一个 Demo1();,编译器就无法判断要选取哪一种方式,所以干脆就不支持 &Demo1();这种写法,你得表达清楚了,我才能确定你要的是谁的地址。所以前一种情况下的&t 就是返回值所在的地址,而后一种情况的 &ta 就并不是返回值所在地址了。

原本 C 中的这种方式倒是也合理,但是 C++ 却引入了「引用」的概念,希望让「xx 的引用」从「语义上」成为「xx 的别名」这种感觉。但 C++ 在实现引用的时候,又没法做到真的给变量起别名,所以转而使用指针的语法糖来实现引用。比如说:

int a = 5;
int &r = a;

语义上,表达的是「a 是一个变量,r 代指这个变量,对 r 做任何行为就等价于对a做同样的行为,所以 r 是 a 的替身(引用)」。但实际上却做的是「定义了一个新的变量 pr,初始化为 a 的地址,对 p 做任何行为就等价于对 *pr 做任何行为,这是一个取地址和解指针的语法糖」。

既然本质是指针,那么指针的解类型就是可以手动定义的,同理,变量的引用类型也是可以手动定义的。(本质上就不是别名,如果是别名的话,那类型怎么能变化呢?)比如说:

int a = 5;
char &r = reinterpret_cast<char &>(a);

上面这种写法是成立的,因为它的本质就是:

int a = 5;
char *pr = reinterpret_cast<char *>(&a);

变化的仅仅是指针的解类型而已。自然没什么问题。既然解类型可以强转,自然也就符合隐式转换特性,我们知道可变指针可以隐式转换为不可变指针,那么「可变引用」也自然可以隐式转换为「不可变引用」,比如说:

int a = 5;
const int &r = a;
// 等价于:
const int &r = const_cast<const int &>(a);
// 等价于
const int *pr = &a;
// 等价于
const int *pr = const_cast<const int *>(&a);

绕来绕去本质都是指针的行为。刚才我们说到rvalue是不能取址的,那么自然,我们就不能用一个普通的引用来接收函数返回值:

Test &r = Demo1(); // 不可以!因为它等价于
Test *pr = &Demo1(); // 这个不可以,所以上面的也不可以

5

常引用与右值

虽然引用本质上就是指针的语法糖,但 C++ 并不满足于此,它为了让「语义」更加接近人类的直觉,它做了这样一件事:让用 const 修饰的引用可以绑定函数的返回值。

从语义上来说,它不希望我们程序员去区分「寄存器返回值」还是「内存空间返回值」,既然是函数的返回值,你就可以认为它是一个「纯值」就好了。或者换一个说法,如果你要屏蔽寄存器这一层的硬件实现,我们就不应该区分寄存器返回值还是内存返回值,而是假设寄存器足够大,那么函数返回值就一定是个「纯值」。那么这个「纯值」就叫做 rvalue。

这就是我前面提到的「语言设计」层面,在语言设计上,函数返回值就应当是个 rvalue,只不过在编译器实现的时候,根据返回值的大小,决定它放到寄存器里还是内存里,放寄存器里的就是 prvalue,放内存里的就是 xvalue。所以 prvalue 和 xvalue 合称 rvalue,就是这么来的。

而用 const 修饰的引用,它绑定普通变量的时候,语义上解释为「一个变量的替身,并且不可变」,实际上是「含了一次 const_cast 隐式转换的指针的语法糖」。

当它绑定函数返回值的时候,语义上解释为「一个值的替身(当然也是不可变的)」,实际上是代指一片内存空间,如果函数是通过寄存器返回的,那么就把寄存器的值复制到这片空间,而如果函数是通过内存方式返回的,那么就把这片内存空间传入函数中作为「类似于出参」的方式。

两种方式都同为「一个替身,并且不可变」,因此又把 const 修饰的引用叫做「常引用」。

等等!这里好像有点奇怪哎?!照这么说的话,常引用去接受函数返回值的情况,不是跟一个普通变量去接受返回值的情况一模一样了吗?对,是的,没错!你的想法是对的!,下面两行代码其实会生成相同的汇编指令:

struct Test {
  long a, b, c;
};


Test Demo1() {
  Test t{1, 2, 3};
  return t;
}


void Demo2() {
  const Test &t1 = Demo1();
  // 汇编指令等价于
  const Test t2 = Demo1();
}

他们都是划分了一片内存区域,然后把地址传到函数里去使用的(也就是返回值转出参的情况)。同理,如果返回值是通过寄存器传递的也是一样:

int Demo1() {
  return 2;
}


void Demo2() {
  const int &t1 = Demo1();
  // 汇编指令等价于
  const int t2 = Demo1();
}

所以,上面两个例子中,无论是 t1 还是 t2,本质都是一个普通的局部变量,它们有内存实体,并且生命周期跟随栈空间,因此都是 lvalue。这是本文第四个重点!!「引用本身是 lvalue」。也就是说,函数返回值是 rvalue(有可能是 prvalue,也有可能是 xvalue),但如果你用引用来接收了,它就会变成 lvalue。

   5.1 目前阶段的结论

这里再回过头来看一下,刚才我们说「函数返回值是 rvalue」这事好像就有一点问题了。从理论上来理解用一个变量或引用来接收一个 rvalue 这种说法是没错的,但其实编译期并不是单纯根据函数返回值这一件事来决定如何处理的,而是要带上上下文(或者说,返回值的长度以及使用返回值的方式)。所以单独讨论 f() 是什么值类型并没有意义,而是要根据上下文。我们总结如下:

  1. 常量一定是 prvalue(比如说1、'a'、5.6f)。

  2. 变量、引用(包括常引用)都是 lvalue,哪怕是用于接受函数返回值,它也是 lvalue。(这里一种情况是通过寄存器复制过来的,但复制完它已经成为变量了,所以是 lvalue;另一种是直接把变量地址传到函数中去接受返回值的,这样它本身也是 lvalue)。

  3. 只有当仅使用返回值的一部分(类似于 f().a 的形式)的这种情况,会使用临时空间(匿名的,会在当前语句结束后析构),这种情况下的临时空间是 xvalue。

   5.2 这里的设计初衷

所以,各位发现了吗?C++ 在设计时应当很单纯地认为 value 分两类:一类是变量,一类是值。变量它有内存实体,可以出现在赋值语句的左边,所以称为「左值」;值没有内存实体,只能出现在赋值语句的右边,所以称为「右值」。

但在实现时,却受到了 C 语言特性的约束(更准确来说是硬件的约束),造成我们不能把所有的右值都按照统一的方式来传递,所以才按照 C 语言处理返回值的方式强行划分出了 prvalue 和 xvalue,其作用就是用来指导析构函数的调用,以实现对象系统的自闭环。

C 语言原本就比较面向硬件,所以它的处理是对于机器来说更加合理的。而 C++ 则希望能提供一套对程序员更加友好的「语义」,所以它在「语义」的设计上是对人更加合理的,就比如这里的常引用,其实就是想成为一个「不可变的替身」。但又必须向下兼容 C 的解析方式,因此做了一系列的语法糖。而语法糖背后又会触发底层硬件不同处理方式的问题,所以又不得不为了区分,而强行引入奇怪的概念(比如这里的 xvalue)。

原本「找补」到这里(划分出了 xvalue 和常引用的概念后)基本已经可以子闭环了。但 C++ 偏偏就是非常倔强,又“贴心”地给程序员提供了「移动语义」,让当前的这个闭环瞬间被打破,然后又不得不建立一个新的理论闭环。

6

再来研究一次返回局部变量


上一篇我们提到过类似于下面这样的实例:

struct Test {
  Test() {}
  ~Test() {}
};


Test Demo1() {
  Test t;
  return t;
}


void Demo2() {
  Test t = Demo1();
}

C++17 对应的汇编指令在前面已经贴出,需要的读者可以去前面取用。当时我们说「常引用去接受函数返回值的情况,跟一个普通变量去接受返回值的情况一模一样」,我相信有读者一定在这里有千百万个问号,为什么会有这样奇怪的设计。这里毫不意外地命中了历史遗留问题,也就是说这个问题也是「找补」之后出现的。所以要想搞清楚,我们就得看看老版本的 C++ 标准下,它是怎么回事。

这里,我们给出 C++14 标准下的汇编(编译参数:-fno-elide-constructors -std=c++14):

Test::Test() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::~Test() [base object destructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::Test(Test const&) [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        mov     QWORD PTR [rbp-16], rsi
        nop
        pop     rbp
        ret
Demo1():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     QWORD PTR [rbp-24], rdi
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]
        lea     rdx, [rbp-1]
        mov     rax, QWORD PTR [rbp-24]
        mov     rsi, rdx
        mov     rdi, rax
        call    Test::Test(Test const&) [complete object constructor]
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        nop
        mov     rax, QWORD PTR [rbp-24]
        leave
        ret
Demo2():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Demo1()
        lea     rdx, [rbp-1]
        lea     rax, [rbp-2]
        mov     rsi, rdx
        mov     rdi, rax
        call    Test::Test(Test const&) [complete object constructor]
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        lea     rax, [rbp-2]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        leave
        ret

当时我们说,针对这种情况,由于 Test 类型是「非平凡」的(因为构造、析构函数都已经自定义了),为了保证对象行为的完整性,Demo1 中的局部变量t需要在其对应的栈空间结束时进行析构。因此就不能再按照平凡类型的方式,直接使用外部的变量了,而是要经过一次「复制」。也就是说,用 Demo1 中的 t 作为参数,调用一次拷贝构造函数来构造 Demo2 中的 t(也就是 Demo1 的返回值),然后再把 Demo1 中的 t 进行析构。

这些都没变,但唯一变化的是相比 C++17 标准多了一次复制和析构,这是哪里的问题呢?通过观察汇编代码我们可以发现,多的一次拷贝是在 Demo2 中。那么也就是说,在早版本的 C++ 中,对于用变量接收非平凡类型的返回值时,按 xvalue 处理。也就是说当我们是用一个变量来接收函数返回值的时候,编译器还是会划分一片匿名的临时空间来接收返回值的,接收完之后再用这个临时对象来构造新的局部变量。因此,这种情况下,返回值就是 xvalue,然后我们用 xvalue 来构造了一个 lvalue。(这是很多其他资料给出的结论,大家不用再质疑了!因为 C++14 及以前版本就是这样设计的)。

正是因为这种设计,我们再去解释「常引用可以接收函数返回值」这件事就更容易了。从语义上来说,常引用是可以直接绑定这片匿名的临时空间的,绑定后,就相当于不再「匿名」。那么,直接用变量接收返回值,其实就等价于先用常引用接收返回值,然后再用它来构造新的局部变量:

void Demo2() {
  Test t = Demo1(); 
  // 等价于
  const Test &tmp = Demo1(); // 常引用接收返回值(临时空间)
  Test t = tmp; // 拷贝构造
}

原本这样设计其实就是能够让这个临时空间拥有一个名字(引用),但这就会出现另一个问题,如果这时,临时空间还是立即释放的话,那么再使用的时候就会出现野指针错误。用上面的例子来说,假如 Demo1() 返回值按 xvalue 来处理的话,那么 const Test &tmp = Demo1();语句结束时,这片空间就应该释放了,临时空间中的对象也要析构掉。那么此时,tmp 这个引用就会指向了已经释放的空间,成为野引用。之后再用 tmp 去构造 t 的时候,就会出现解野指针错误,这显然是违背了原本「给临时空间起个名字」的用意。

为了解决这个问题,C++ 不得不让这片临时空间「延长它的寿命」,这样后面才能去使用它。所以,当用常引用接收函数返回值时,临时空间不会立即释放,而是跟随常引用成为了栈上的变量。所以上面例子中,tmp 所指的对象并不会立刻析构,而是会等到 Demo2 函数结束。

这样来说事情就特别奇怪了,用常引用接收的函数返回值不仅没有成为 xvalue,反而是成为了一个独立的变量了,比较违背直觉(直觉是,引用了临时空间,但实际上这种情况下反而没有临时空间了,而是会出现一个 lvalue)。但如果直接用变量来接收返回值的话,倒是会出现一个临时空间(返回 xvalue),然后再多一次拷贝(用临时对象拷贝构造局部对象)和析构(析构临时对象)。这也很反直觉(直觉是用局部变量接收返回值,但其实是多生成了一次 xvalue)。

离谱……相当离谱!难道就没有一种完美的方案,可以表达这种「用局部变量接收返回值」并且「不出现额外的临时对象」吗?右值引用就这么诞生了!

7

右值引用与复制省略

以 C++14 及以前的标准来说,我们发现,如果直接用一个变量来接收返回值,会多一次临时对象的拷贝和析构,用常引用虽然可以减少这一次拷贝,但常引用是用const修饰的,不可修改(如果要修改的话,还是得再去拷贝构造一个新的变量)。而为了解决这个问题,C++ 引入了「右值引用」。

其实这个语法完完全全就是为了解决函数返回值问题的,但为什么叫「右值引用」呢?我们在前面解释过,从语义上来说,返回值可以理解为都是 rvalue(可能是 prvalue,可能是 xvalue),因此用来接收 rvalue 的引用,就被叫做了 rvalue-reference,翻译为「右值引用」。但大家一定一定要知道的是,这是「语义」上的解释,实际只要有引用来接收函数返回值的话,它就会变成 lvalue。

void Demo2() {
  Test &&t = Demo1(); // 用右值引用接收函数返回值
}

从行为上来说,右值引用接收函数返回值和用常引用接收函数返回值的情况几乎完全相同,区别仅仅在于,右值引用不需要 const 修饰,因此可以更改。相比直接用变量来接收的情况,少了一次 xvalue 的中间值,也就减少了一次复制和析构。那么结论也就呼之欲出了:右值引用从语义上来说,是对右值的引用,但一旦完成了这种引用,其实整个过程就不会出现右值了,而是用一个左值来保存返回值,这就是我们为什么一直强调说「右值引用本身是左值」了。

来看一下完整的实例:

struct Test {
  Test() {}
  ~Test() {}
};


Test Demo1() {
  Test t;
  return t;
}


void Demo2() {
  Test &&t = Demo1();
}

汇编结果(编译参数:-fno-elide-constructors -std=c++14):

Test::Test() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::~Test() [base object destructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        nop
        pop     rbp
        ret
Test::Test(Test const&) [base object constructor]:
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], rdi
        mov     QWORD PTR [rbp-16], rsi
        nop
        pop     rbp
        ret
Demo1():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     QWORD PTR [rbp-24], rdi
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]
        lea     rdx, [rbp-1]
        mov     rax, QWORD PTR [rbp-24]
        mov     rsi, rdx
        mov     rdi, rax
        call    Test::Test(Test const&) [complete object constructor]
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        nop
        mov     rax, QWORD PTR [rbp-24]
        leave
        ret
Demo2():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-9]
        mov     rdi, rax
        call    Demo1()
        lea     rax, [rbp-9]
        mov     QWORD PTR [rbp-8], rax
        lea     rax, [rbp-9]
        mov     rdi, rax
        call    Test::~Test() [complete object destructor]
        leave
        ret

有没有发现,这种情况下跟 C++17 标准下,直接用变量接收函数返回值的情况是一样的了。那么也就是说,C++17 标准下,针对于变量直接接收函数返回值的这种情况,规定了减少一次 xvalue 的生成,我们称之为「复制省略(Copy Elision)」。

   7.1 小结一下

所以整件事情的心路历程就很有意思了,我们来小结一下整个「找补」的过程:

  1. 对于非平凡类型,为了保证对象的行为完整性,函数返回值会单独作为一个临时对象,如果需要在栈上使用,那么会拷贝给栈上的变量。

  2. 为了希望这片临时空间能够被代码捕获到,于是允许了用常引用来绑定函数返回值。但如果这时返回值仍然保持 xvalue 的特性的话,会引入野指针问题,违背了「引用临时空间」的原意,因此不得不将这种情况改成lvalue,让常引用所引用的空间跟随其所在的栈空间来「延长」声明周期。

  3. 又因为常引用有const修饰,不能修改对象,因此引入了「右值引用」,当用右值引用绑定函数返回值时,行为跟常引用是一致的,可以减少一次xvalue的生成,「延长」声明周期,同时还可以修改对象。

  4. 又发现还是直接用变量来接收函数返回值更加直观、符合直觉,而这种情况下xvalue的生成并没有太大的必要,因此又规定了「复制省略」,来优化这一次复制。(优化之后,用变量接收函数返回值和用右值引用接收函数返回值就完全没有区别了;而用 const 变量接收函数返回值跟用常引用接收函数返回值也没有区别了。)

这里需要额外解释一下,上面的实例我们都添加了 -fno-elide-constructors 这个编译参数,其实它就是用于关闭编译器的自动复制省略的。在 C++17 以前,虽然语言标准是没有定义复制省略的,但编译器早早就发现了这个问题,于是做了一些定制化的优化(称为返回值优化,Return Value Optimization,或 RVO),这个参数就是关闭 RVO,完全按照语言标准来进行编译。而在 C++17 标准中,定义了复制省略的方式,因此编译器就必须按照语言标准定义的那样来处理返回值了,所以在 C++17 标准下,这个编译参数也就不再生效了。

通过上面的介绍,这个 value 体系应该闭环了吧?不!还差得远呢……

8

移动语义

原本,右值引用概念的引入就是为了做返回值优化的,但有了 Copy Elision(以下简称 CE)以后,仿佛右值引用在这个场景下了一个菜鸡,但这并不意味着右值引用将会成为历史语法而惨遭淘汰。因为它还有另一个重要的用途——移动语义。

移动语义原本是为了解决资源复用问题的,我们来看下面这个实例:

class String {
 public:
  String();
  ~String();


  String(const String &);


 private:
  char *buf_;
};


// 由于算法本身不是本例程的重点,因此忽略掉一切扩容和优化问题,简单书写
String::String(): buf_(new char[1024]) {}
String::~String() {
  if (buf != nullptr) {
    delete [] buf_;
  }
}


String::String(const String &str) : buf_(new char[1024]) {
  std::memcpy(buf_, str.buf_, 1024);
}


void Demo1() {
  String str1;
  // 这里对str1做了一些操作,比如说添加了一些数据之类的
  return str1;
}


void Demo2() {
  String str = Demo1(); // 会触发一次拷贝构造
}

注意在上例中,我们用一个简单的字符串处理类来说明问题。Demo2 中,用 str 来接收 Demo1 的返回值,这里会触发 CE,直接用 Demo1 中的局部变量来拷贝构造这里的str。拷贝构造会调用拷贝构造函数,而我们可以看到,拷贝构造函数中是一次内存的深复制。也就是说,我们构造 str 会先分配一片空间,然后把 str1 中的 buf_ 对应的数据拷贝到了 str 的 buf_ 中,然后跟随着 Demo1 的结束,刚才 str1 的这片空间会被释放掉(析构函数中有delete [])。

这平白多一次内部的数据复制,就成为了 C++ 希望优化的点。假如说,新的对象能够「直接拾取」原有对象的内部空间,岂不是可以节约资源,减少复制?于是C++引入了「移动构造函数」和「移动赋值函数」,就是说,当你用了一个「马上就不用的对象」来构造新对象的时候,就调用这个移动构造函数,里面应当执行浅复制,来延长内部资源的寿命。

那么,怎么区分「马上就不用的对象」和「一会还要继续用的对象」呢?看这里所谓「马上就不用的对象」是不是很符合 xvalue 的定义?那我就看看,如果我是用一个 xvalue 来构造新对象的话,我就复用资源;而如果是一个普通的 lvalue 的话,那说明它后面还有用,我就复制资源。那如何表示这个参数只接受 xvalue 呢?有三种方法:1.用变量接收;2.用常引用接收;3.用右值引用接收。

那么这里,C++又从「语义」上做了区分。当右值引用做函数参数时,认为优先匹配函数返回值。什么意思呢?就是对于重载函数的情况,如果我们直接用函数返回值作为实参的话,优先匹配右值引用的重载。用例子来说就是:

#include <iostream>


struct Test {};


Test Demo1() {
  Test t;
  return t;
} 


void f(const Test &) {
  std::cout << 1 << std::endl;
}


void f(Test &&) {
  std::cout << 2 << std::endl;
}


void Demo2() {
  Test t;


  f(t); // 1
  f(Demo1()); // 2
}

这里有2个 f 函数的重载,对于 f(t) 这种调用来说,由于t本身是普通变量,不是直接函数返回值,那么这种情况只能命中常引用的版本,所以会打印1。而对于 f(Demo1()) 这种调用来说,两个版本的f都可以匹配,但由于我们刚才提到的优先原则,如果存在右值引用的重载版本,遇到直接用函数返回值作为形参的这种情况,优先匹配右值引用的重载,所以会打印2。

大家注意,这里的这种优先原则并没有什么道理可言,就是语言标准强行规定的,用于区分你是变量传入,还是函数返回值直接传入。所以,有了这个原则,我们就可以完善刚才的移动构造函数了:

class String {
 public:
  String();
  ~String();


  String(const String &);
  String(String &&); // 移动构造函数


 private:
  char *buf_;
};


String::String(String &&str): buf_(str.buf_) { // 直接浅复制
  str.buf_ = nullptr;
}
// 【其他函数实现省略,可以看前面的例程】


void Demo2() {
  String str = Demo1(); // 调用移动构造函数
}

有了这个例子我们就知道了,右值引用最大的价值已经不在于优化返回值了,而是用于标记实参是否是直接的函数返回值。

重点来了!! 有些教程资料可能会这么解释:函数返回值是右值,所以有右值引用接收,所以表「移动」语义的函数参数是右值引用。乍一看这个说法好像没问题,但其实经不起推敲,因为其实整个过程没有出现任何一个右值。对于 String 的移动构造函数来说,str 是右值引用,在它的内部就是一个普通的变量,当我们在 Demo2 中用他来接收 Demo1 返回值的时候,命中了「右值引用接收函数返回值」这一情况,根据我们之前的分析,此时 str 是 lvalue。所以整个过程是没有出现一个 rvalue 的。

这就是笔者反复强调,C++ 的「语义」和「实际处理」的区别。所以这里从语义上来说函数返回值是 rvalue,包括常数也是一种 rvalue,所以右值引用做函数参数时,用于「接收」一个 rvalue。那么这里更加强调的是语义上的「接收」,这里希望接收一个右值。但右值引用本身其实就是一个栈上的普通变量,它是 lvalue。

笔者更希望大家能够看到它的本质,右值引用做函数参数是为了优先匹配直接传入函数返回值的情况,从而跟常引用做参数来进行区分。匹配之后会按照返回值转出参的这种方式,成为一个栈上的普通变量,自然就是 lvalue。

而通常情况下,用右值引用接收一个对象,是为了复用它的资源,来进行浅复制的。就好像,我们把原本的资源「移动」到了新的对象当中去,因此称之为「移动语义」。含有移动语义的构造函数就称为「移动构造函数」、含有移动语义的赋值函数就称为「移动赋值函数」。所以大家一定要清楚,这里的「移动」是「语义」上的,并没有真的移动,一般就是用来做浅复制的。当然了,你确实可以用右值引用做参数但是不做「移动」的事情(就比如说我们之前的例子中那个 f 函数一样),所以更加说明了这是「语义」上的,而实际只是一个软约束。

这样一来这个值类型体系总该闭环了吧?兄弟你还是太天真了,接下来就是整个体系里最复杂的一个环节——std::move。

9

Redis 分布锁存在的问题

刚才我们解释了如果用一个右值(函数返回值、函数返回值的一部分、或者常数)做参数时,会命中右值引用的重载版本,从而实现移动语义,做浅复制,来节省资源。

但如果我们想对一个不是右值的量做同样的事情呢?这里还是用上一节的 String 为例:

void Demo2() {
  String str1;


  String str2 = str1; // 这里会调用拷贝构造,因为str1是左值
}

如果我希望,用 str1 构造 str2 时,不用拷贝构造,而是用移动构造呢?或者说,虽然 str1 是个左值,但我仍然希望复用它里面的资源给到新的对象,这怎么办?这就要用到魔法操作了。我们知道,如果要进行移动语义,那么就需要用右值引用来接收。但现在 str1 是个左值,我们要是能给他强行「掰右」的话,不就可以「欺骗」编译器,把它当做右值来处理了嘛。反正移动语义本身就是个软约束,又不会真的去 check 入参的左右性。

所以,我们的魔法操作就是,把这个 str1,伪装成右值,骗过编译器去触发右值引用的重载函数。像这样:

void Demo2() {
  String str1;


  String str2 = static_cast<String &&>(str1); // 强制转成右值引用,去触发移动构造函数
}

这里多说一嘴,定义新变量时后面的等号并不是赋值,而是构造参数的语法糖,也就是说上面等价于。

String str2(static_cast<String &&>(str1)); // 构造参数,所以是用来匹配函数参数的

上面的这个操作由于过于魔幻,因此 STL 提供了一个工具函数来封装这个魔法操作,由于它的目的是为了触发移动语义,因此这个函数被命名为 std::move,下面是它的实现:

template <typename T>
constexpr std::remove_reference_t<T> &&move(T &&ref) noexcept {
  return static_cast<std::remove_reference_t<T> &&>(ref);
}

因此,刚才的代码也可以写作:

void Demo2() {
  String str1;


  String str2 = std::move(str1); // 强制转成右值引用,去触发移动语义
}

那么这里请读者一定一定要把握一个原则,std::move 的本质是为了伪装,它并不能改变变量的左右性。也就是说,std::move(str1) 并不能把 str 变成 rvalue,它本身是个变量,那么它就是 lvalue,一直都是。move 的作用仅仅在于,构造 str2 的时候能触发移动构造函数,仅此而已,其他的什么都没变。

那么也就是说,尽管我们用了「移动语义」来构造了 str2,但其实 str1 还是存在的,该是什么样还是什么样,并不会真的被「移动」。而此时的 str2 是 str1 的浅复制版本,原本的话它们的 buf_ 会指向同一片空间的,但因为我们在移动构造函数中强制把原来的对象 buf_ 给置空了,因此这里 str1 内部会出现空指针。所以这里有一次印证了「移动语义是软约束」这件事,使用之后行为如何,会不会出问题,完全取决我们代码怎么写的。

10

总结

还有一个概念笔者一直都没有提,那就是 glvalue(广义左值,Generalized Left-side-hand Value),lvalue 和 xvalue 合称 glvalue,原因就是他们都有内存实体。但其实这个概念并不常用,主要是因为 xvalue 虽然有内存实体,但是无法直接取地址,因此在主框架的设计中,还是把 xvalue 当做 rvalue 来处理了。

C++ 之所以会出现这么多难搞的值类别,就是为了在兼容 C 方式的同时,提供一种更高级的语义封装。所以 C++ 纠结就纠结在这里,一方面希望提供一些高级的语法,让程序员可以屏蔽掉一些底层的概念。另一方面反倒又引入了奇怪的概念让程序员不得不去深入理解底层。所以笔者自己对 C++ 的经验就是,学习的时候要「深」,一定要搞清底层;而实际使用的时候要「高」,应当使用更加符合直觉的高级语法来屏蔽底层实现。

本篇文章并没有直接去按理论列举 C++ 有哪些值类型,分别是什么定义。而是带着大家从汇编指令出发,一点一点的去猜测和体会这样设计的初衷和底层原理,希望能够给读者提供一些不同角度的理解和不一样的思路。

-End-

原创作者|胡博豪

cffc615f115f10a1d270c735668c1839.png

C++ 的值类别在项目中,有哪些实用的功能?欢迎分享。我们将选取1则最有价值的评论,送出腾讯标准型Q哥1个(见下图)。11月2日中午12点开奖。

d44af4afce61576ba7895d67d151a658.png

📢📢欢迎加入腾讯云开发者社群,社群专享券、大咖交流圈、第一手活动通知、限量鹅厂周边等你来~

811a5a7393c3d6d9454a85f7d55f6c8d.png

(长按图片立即扫码)


25ff3cc39783c5627e9c7c427ba14664.png

651e9f8d91cafc7d8f40ef7168141f91.png

f098d91da86a0ba6d9d38c00def0ffa8.png

80e8c9cee141d770a4ce861b24d06108.png

相关推荐

大模型的Agent Skill功能,在LLM HTTP底层交互流中是怎么承载的?

网络文章文本的 skill,昨天我实现了之后也就开始好奇起 Skills 的底层原理了——相比起各种花里胡哨的 agrnt 应用,我一直以来都很对大模型在纯粹的 HTTP 交互层面是如何交互的更感兴趣。Skill 的全部"魔法"都发生在 system prompt 的措辞和 SKILL.md 文件的编写质量上——本质上是一种 prompt engineering + 文件系统的组合。但是各种天花乱坠的 skills,是如何在底层的 HTTP 中,与大模型——这个只会嘴遁的工具交互的呢?

QcloudCommunity的博客 407

万字入门AI Infra:深入理解大模型中的数学与Infra优化

关注腾讯云开发者,一手技术干货提前解锁👇AI Infra科普、入门或者进阶 ~~ 不到 5 万字,带你融会贯通理解大模型的数学、算法、硬件到系统工程。任何问题欢迎沟通交流。可怕,我竟然有点认同这句话。当然大概率是因为姚顺宇太懂AI了,而我则是因为无知者无畏。不过仔细想想,大模型推理中的数学逻辑确实不复杂,很多原理只需要高中数学知识就能看懂。但是为什么像 vLLM 这种推理系统这么复杂呢?本文将拆解大模型中几个核心操作(RMSNorm、Softmax、Causal Mask、Sampling)背后的数学与

QcloudCommunity的博客 1169

平平无奇的源码,竟藏着Agent的核心秘密?

System Prompt 是剧本,Skill 是剧本的扩展包,Agent Loop 是演员按剧本行动。欢迎留言,我们将邀请作者针对性回复你的评论,我们将选取1则优质的评论,送出腾讯云定制文件袋套装。,让 Agent 能主动"巡逻",而不只是被动等待用户消息。OpenClaw 的 System Prompt 分层结构。的"行为底线",任何 Skill 或用户命令都无法覆盖它。精华 2:Skill 的"按需加载"避免 token 浪费。精华 1:System Prompt 是"分层乐高积木"

QcloudCommunity的博客 426

QQ音乐Harness Engineering实践

一个看似简单的需求,背后可能牵动服务调用链、配置、灰度、埋点、错误码、接口契约和历史兼容性。当 AI 开始快速生成大量代码,真正的瓶颈就不再是"写不出来",而是"看不完、想不清、管不住"。在对话式编码阶段,一种典型的工作模式逐渐流行:开发者把需求丢给 AI,扫一眼输出"看起来对"就直接采纳,不审 diff、不追问逻辑、不验证边界。以音乐商业化业务为例,一个需求可能从 TAPD 单开始,经过需求评审、技术方案、服务影响面分析、IDL 契约变更、业务代码实现、测试验证、CR、灰度上线,最后才进入稳定运行。

QcloudCommunity的博客 716

从Prompt、Context到Harness,工程的三次进化与终局之战

同时,强制要求散落各处的决策记录(Slack、邮件、文档)全部迁移至代码仓库,确保 Agent 的唯一信息来源是可信的、版本受控的仓库。更坑爹的是,研究表明,当上下文过长时,模型会出现"中间遗忘(Lost in the Middle)"现象:它对开头和结尾的内容记忆较好,对中间大段内容的关注度大幅下降。这篇文章,我想带你完整走一遍这三次进化的逻辑:它们分别解决了什么问题,它们之间是什么关系,它们的边界在哪里,以及:当三者融合,AI 工程师的终极形态究竟是什么?大语言模型的本质,就是这位金鱼助理。

QcloudCommunity的博客 719

让Skill自己训练自己:8阶段Loop、3层评测、5维AND门控,从此实现自进化

所以每一轮改动都是有据可查的,不是「感觉这里可以优化」,而是「Case 41 挂了,因为 agent 把离职问题路由到了邮箱分类,但正确答案在通讯录,所以我改 root_index.md 加个易混淆提示」。但让我最后决定把它记录下来的,不是这的个「吸收」过程,而是它真的在替我探索我不想费脑力触达的边界,这看起来更像是一个机器智能应该有的样子。不准跨层,每轮只改一层的东西。但我经过这 19 轮之后觉得,更准确的描述是互补——你在明处看着,AI 在暗处替你试错,你看不见的那一半就是 AI 能贡献的地方。

QcloudCommunity的博客 1128

只加两行代码,为什么要两天?一文深度理解业务系统的复杂性

关注腾讯云开发者,一手技术干货提前解锁👇业务系统复杂性一直是令开发者头痛的问题。复杂的不是增加一个需求需要耗费多少时间,而是在增加一个需求后带来的蝴蝶效应:其它功能会不会受到影响、要如何去找到这些影响,最终如何实现系统正常运行......功能之间隐秘增加的耦合、不可避免的代码腐化在导致业务复杂性增加。大家都在说的软件开发提效到底在提什么?程序员日常工作中应该如何提升开发效率?敏捷开发、瀑布流式开发孰是孰非?欢迎阅读。业务背景与目标我依然非常清晰地记得某个时候,我所在团队 Leader 曾讲过一段话:“我担

QcloudCommunity的博客 713

从零设计生产级 Multi-Agent Harness:架构、评估、记忆、成本与 MCP 工具接入全拆解

在 AI Agent 领域,Multi-Agent Harness 指的是把多个 Agent 的能力、工具、状态、通信、编排、监控统一收束在一个运行时之内的框架。第三,Agent 路由。一个输入框,一个大模型,几个工具,一段写得很漂亮的 System Prompt,再配上一个炫酷的前端,看起来就像一个能干活的“数字员工”。Multi-Agent 完全不一样——它有计划、有中间步骤、有工具调用、有 Agent 协作、有重试、有反思、有最终合成。增加 Budget、权限、重试、压缩、轨迹评估、审计、回归测试。

QcloudCommunity的博客 710

拆完Hermes源码,我发现Agent的“自我进化“根本不需要训练模型

两个月 5.2 万 Star,Hermes Agent 用一个"LLM 审判官"机制实现了 Agent 的自我进化——不改模型权重,只改"怎么用模型"的策略。OpenClaw(社区昵称"龙虾"🦞)是 2025-2026 年最火的开源 Agent 框架,30 万+ Star,插件市场 ClawHub 里有数千个插件,能接入 Telegram、WhatsApp、Slack、飞书、企业微信——几乎是一个"个人 AI 操作系统"。Skill 是英语写的,Memory 是英语写的,审查 Prompt 也是英语写的。

QcloudCommunity的博客 911

AI Infra 其实没有多少新东西

传统 Infra 追求横向扩展,而 AI Infra 呈现 “AI 大型机”特性,是因为传统后台服务的可以容忍毫秒级延迟,但 AI 集群不行,GPU 的算力是 CPU 的数百倍,微秒级的延时等待也会造成很大的算力损耗,需要硬件的高度集成。在可预见的1-3年的未来,这样的专用硬件+网络的集中式架构很难发生比较大的改变。与之相似,模型推理的批处理就是将多个输入样本打包(batch),将原本串行的 N 次轻量的推理计算,合并为 1 次重量的计算,实现单位时间内处理更多的请求,提高了 GPU 利用率。

QcloudCommunity的博客 826

程序员越早想通这些越好

永远没有正确架构,你永远无法偿还完所有的技术债务,如同你永远不会设计出完美的界面,请避开完美主义的陷阱,永远没有完美的代码,能够满足当前需求,又为未来不管是自己还是他人留有扩展空间,就很好了。我们努力的方向就是将现实世界映射到有限的数据结构中,这就需要用户自定义类型,如果你的代码中包含类似 trader portfolio 这样的概念,你就可以使用他们的名称来建模,而不是使用基本数据类型复杂嵌套表述你的目的。从另一个角度看,代码里的注释都是补丁,是碎片化的,局部的注释很难推导模块整体的顺序及耦合关系。

QcloudCommunity的博客 466

RAG已死?不,是Grep回归了!

这样一来可以直接复用已有的计算缓存,只为新增的增量部分付全价,前面累积的大头按约 1/10 的缓存价计费。所以实际的工具组合方式是灵活的:Grep(默认模式)→ Read 是最常见的路径,但 Grep(content 模式)可以独立使用,LLM 也可以直接调 Read(如果已经知道文件路径),或者一次同时发起多个 Grep 并行搜索。它从零开始构建自己的对话历史,不继承主对话的消息,这意味着它搜索过程中产生的大量 grep 结果、代码片段都留在自己的 context 里,主对话只收到一段总结性的文本结论。

QcloudCommunity的博客 576

深入浅出Harness Engineerring之核心模式与理念

在智能体生命周期的关键节点(如会话开始、工具调用后)自动触发预设动作(如代码格式化),由系统确保关键流程被执行,不依赖可能被模型遗忘的指令。简单讲就是利用向量存储这个技术,来实现模糊检索,原理是:即使字面不同,但语义相近的文本,其向量在数学空间中的位置也很接近。根据命令类型、参数和影响,自动评估其风险等级(安全、有风险、危险),并采取自动执行、请求确认或直接拦截等不同策略。关键特性是可隔离、可重建、可扩展。不是一次判断就定终身,允许你改变、允许情况复杂,通过不断观察、思考、调整,越来越懂真实的你。

QcloudCommunity的博客 625

Harness Engineering实践心得:如何高效驾驭AI?

但如果这些经验被拆成一条条 Rule、一个个 Skill、一项项 Script 检查——"XAML 不能有中文"、"编译要用这个路径的 MSBuild"、"SVN 命令必须带认证参数"——AI 就能在秒级时间里"吸收"十年的踩坑经验。然后可以看到下方的图,我的PM会很顺利的调度其他agent分别负责不同的事项,遇到问题的时候也能准确的找到合适的agent。MCP 本质上是在扩展 AI 的"感知范围"——Rule 管"该怎么做",Skill 管"怎么操作",MCP 管"能看到什么、能碰到什么"。

QcloudCommunity的博客 843

从第一性原理思考 Agentic Engineering

需要注意的是,这一结论是有条件的:如果 AI 缺乏领域知识,过早介入反而可能引入 1.2 节所述的"似是而非"损耗——因此上下文供给(实践 1)是 AI 全链条参与的前提,而非结果。通过一个专门的自迭代 Skill 实现——当 AI 在协作过程中识别到自己被纠正(用户否定了 AI 的输出并给出了正确方向),它自动评估这个错误的根因,搜索现有的 Rules 和 Skills 中是否已有针对该类问题的处理规则。事实上,越是复杂的项目,工程师的认知负担越重(公理 3),AI 分担认知负担的潜在边际价值也越大。

QcloudCommunity的博客 757

万字干货!Harness Engineering如何工程化落地?

关注腾讯云开发者,一手技术干货提前解锁👇Harness Engineering 的概念已经火了有一阵了,全网很多文章基本都是在讲理念,讲为什么今天做 AI 开发,不能只靠一段提示词,也不能把模型当一个“更聪明的代码补全”。但与此同时,一个问题也在持续地发酵:这个问题特别重要。因为 Harness 这个词听上去很大,很像一个抽象的方法论,但它如果不能落到工程、目录、文档、脚本、工作流里,那它最后就只是一句漂亮的话。事实上,不同项目落地出来的 Harness,表面上可能完全不一样。有的项目是 CI 很强,有的

QcloudCommunity的博客 1171

全方位对比:Hermes VS OpenClaw

多账号矩阵运营 如果你的业务涉及同时管理多个社交媒体账号、多个平台的内容分发、多渠道的客户互动——OpenClaw是目前市场上的"无可替代的底座"。一个有专业背景的个人,现在可以快速构建一个垂直领域的AI助手:比如"财务分析Hermes"、"法律咨询Hermes"、"技术架构Hermes",直接通过微信提供服务,积累自己的专业IP。跨平台生态融合 如果你的工作流涉及飞书、Slack、Discord等多个平台的深度集成,需要这些平台之间的数据流转和联动——OpenClaw的生态支持是强大的。

QcloudCommunity的博客 1218

一文讲透:Harness Engineering即控制论!

而研发模式的升级我认为将会是一个飞跃的过程,之所以现在我们仍然需要需要参与编码,一个非常大的原因就是缺乏传感器和基建,仍然需要人来串流程,比如需要人来验证UI是否正确、需要人来告诉AI代码不符合代码规范,因此在有些场景我们仍然感觉 AI 完成的很吃力,但这不是 AI 能力不行,而是我们并没有为 AI 提供友好的环境……控制论中的突变理论介绍了矫枉过正和飞跃现象之间的矛盾,如果质变中经历的中间过渡态是不稳定的,那么他就是一个飞跃的过程,如果中间过渡态是稳定的,那么他就是一个渐变的过程。但是这些阶段要解决的。

QcloudCommunity的博客 1204

神级开源插件!一句话让QClaw变3D小镇,Agent工作可视化,赛博云监工

这个架构是翻了几次车才想通的—原有AI的实现机制是用 setTimeout 猜动画时长导致了幽灵 NPC、工位撞车、越改越崩,后面我停下来换了思路,推翻原有的架构,按照“意图+回传”的架构进行重构,之前的问题一次性全部解决。15 天,我和 AI 吵了 185 次架, 4.5 万行代码,开发了一款 QClaw / OpenClaw 的UGC游戏插件,这可能是人类跟 Agents 交互的新范式,插件已完全开源,有需要的欢迎自取~我天天用,用着用着我就在思考,Agent 产品现在的交互体验,基本都一个样。

QcloudCommunity的博客 1197

一文搞懂Hermes:新顶流Agent如何从经验中自我进化

Voyager 是一个能在 Minecraft 中自主探索、学习技能、无限积累能力的 AI Agent,它提出了 "Skill Library"(技能库)的概念——Agent 将成功的行为序列编码为可复用的技能函数,存储在一个持续增长的代码库中。如果 Skill 的名称和描述不够精准,或者用户的任务描述与 Skill 的触发条件有语义差距,Agent 可能会错过相关的 Skill。如果进程在写入过程中崩溃,目标文件要么是旧内容(还没被替换),要么是新内容(替换已完成),绝不会出现写了一半的损坏文件。

QcloudCommunity的博客 2637

自掏腰包一万元,拥抱AI这一年,我的工具、实践和思考

其实也很好理解,过往的每个领域(比如前端、后端、设计、测试等等)都主要是这个领域的从业者在为它添砖加瓦,但是大模型时代的 AI 应用领域却几乎是所有使用 AI 的人类一起在迭代,无分领域,无分文理,无分老少。因为每个时期的 AI 都有着不同的特点,很多时候当我费尽心思去钻研,自以为有点弄明白 AI 应该怎么玩的时候,基座模型和行业范式常常就会迎来颠覆式的变革,很多过往的经验都会倾覆,然后只能从头再来。过去一年多,被热议的 AI 范式大概是沿着四个阶段递进演化,每一个阶段其实都在解决前一个阶段的核心问题。

QcloudCommunity的博客 627

办公Agent的CI/CD时刻到来了

核心观点是:企业给员工配了一堆 AI 工具,试点跑了几百个,但真正拖慢 AI 转型速度的瓶颈不在模型能力,在"最后一公里":AI 输出和实际工作流之间的那道鸿沟。代码写完,打个 tar 包,开 FTP 传到服务器上,SSH 进去解压,改配置文件,重启服务,刷一下页面祈祷别 500。你复制,切窗口,粘贴到腾讯文档里,发现 Markdown 格式全乱了,手动调标题层级,代码块重新标记语言类型,表格散架了重排一遍。模型是越来越聪明了,但"生成"到"落地"之间那段路,还是你自己在走,一步一步,手动搬运。

QcloudCommunity的博客 608

4亿token买来5个教训:让6个AI Agent连写4天代码发生了什么?

Watchdog 检测到崩溃 → 启动诊断 Agent 分析原因 → 诊断 Agent 跑满 20 轮没搞定 → Watchdog 判定“已修复”,重启系统 → 重启的系统因为诊断 Agent 留下的环境变量被继承,连续 3 次拒绝启动 → 触发连续失败保护退出 → Watchdog 第 3 次巡检,发现进程和记录文件都没了,尝试手动重启,自己也停了。启动前我翻了论文、做了架构设计、写了监控+修复异常的脚本。这个发现让我的情绪从沮丧变成了兴奋——不是那种"终于修好了"的释然,是"我找到根因了"的快感。

QcloudCommunity的博客 584

赛博斗蛐蛐:9大模型决战三国志,天命在谁?

我猜是这样的,当Gemini面临决策的时候,一系列关键词比如 守城,劣势,粮草,三国等等,在语义层面的关联性中LLM发现了竖壁清野这个关键词概率非常高,所以以此为策略,然后再根据这个策略完美执行操作。MiMo 的外交是三方中最精明的。Kimi作为国产模型,也同样颠覆了我对他的看法,最后的比赛他甚至一度是优势者,存在很多夺冠的可能性,要知道他的对手可是claude和gemini,而他经常出兵慢,回过头来想想或许正是他的策略,毕竟中后期他的优势都来自于稳健的发展和较少的战斗频率(和claude比).

QcloudCommunity的博客 875

Claude Code是怎么知道你在骂他的?这 12 条发现值得关注

确实存在——5,500+ 行,集成了消息队列、工具装配、MCP 编排、会话状态、权限、分析、文件持久化和优雅关闭,基本上一个文件干了所有事。对抗虚假声明——"不要在输出显示失败时声称所有测试通过,不要压缩或简化失败的检查来制造绿色结果"。完整的 KAIROS 是一个持续驻留的守护进程,能感知你在不在电脑前、主动寻找有用的工作做,更像是住在终端里的全职同事。源码里藏着一个叫 "Buddy" 的电子宠物系统,完整度令人惊讶——这不是一个 TODO,而是一个从数值系统到 ASCII 动画都实现了的完整功能。

QcloudCommunity的博客 701

逆向深扒Claude Code源码,我发现了什么!?

Anthropic 内部用户获得更严格的质量控制 prompt、更好的验证机制(独立 Verification Agent)、以及针对 model 弱点的专门对策(如 Capybara v8 的 29-30% 错误声明率对策)。这不是代码混乱的标志——它是整个 Agent Loop 的心脏,所有的流式处理、工具调度、上下文压缩、子代理管理都在这个文件中协调。这种"胖核心"设计是刻意的:保持核心循环的原子性,避免分散到多个模块导致的协调复杂度。核心价值:Fork 代理的工具输出不会回到主代理的上下文窗口。

QcloudCommunity的博客 892

一文讲透如何构建Harness——六大组件全解析

本文将从"裸模型的四个硬伤"出发,逐一拆解 Harness 的六大组件——文件系统、Bash + 沙箱、记忆(AGENTS.md)、Web Search + MCP、上下文工程、编排 + Hooks——带你看清 AI Agent 真正的竞争壁垒,不在模型层,而在 Harness 层。如果你用过 Agent 做复杂任务,你一定有过这样的体验:一开始 Agent 的表现很好,但随着对话变长,它开始"变笨"——遗忘之前的约定,重复之前犯过的错误,甚至对同一个问题给出前后矛盾的回答。对于简单的问答场景,这无所谓。

QcloudCommunity的博客 761

Harness Engineering 来了,SDD 还有意义吗?

他们的解法是把「品味」编码进规则,然后用一个定期运行的「doc-gardening」Agent 自动扫描漂移、发起修复 PR——「技术债务就像一笔高息贷款,不断地以小额贷款的方式偿还,总比让债务不断累积要好」。代码仓库本地的、已版本化的工件,才是 Agent 所能看到的全部。在 Vibe Coding 模式下(即不做规划、随意向 AI 提需求的开发方式),大量设计决策、跨服务约定、「为什么不选另一个方案」的讨论,全部停留在一次性的 AI 对话里——下一个人,或者下一次 AI 会话,完全无从获取。

QcloudCommunity的博客 419

零废话!一文讲透从0构建AI Agent

每个工具都要写一套"定义→解析→执行"的胶水代码。上下文管理就是在"记住足够多"和"别超标"之间找平衡,常见策略包括滑动窗口、摘要压缩、RAG 检索增强。上下文窗口是 Agent 的"工作记忆",但它有硬性限制。LLM 负责"动脑"决策,代码负责"动手"执行。这是从"聊天机器人"进化到"Agent"的关键一步。每次调 API 都把完整对话历史发过去,LLM 本身是无状态的,"记忆"完全靠客户端的数组模拟。这样 Agent 一开始就知道自己"在哪里"、"手头有什么",不需要先花一轮工具调用去探索环境。

QcloudCommunity的博客 711

距离AI把小编我裁掉还有72小时

这是一个基于 OpenClaw 开源生态打造的本地化 AI Agent 助手,已于上周开启全量公测,无需复杂配置,三步即可上手,自带安全防护,支持微信直连绑定,内置多款优质国产大模型,现阶段也是完全免费使用,基本上前面提到过的痛点都可以靠它解决。对了,这里特别强调一点,上面的截图让产品同事汗流浃背,再三找我确认 QClaw 思考过程中优美的“草”字说法,不会是默认出现的吧?AI 好,AI 得学,但更重要的是,在你的工作和生活里,哪些东西是能结构化地被 AI 所接入的,不要死守着那些脏活累活不放。

QcloudCommunity的博客 674
上一篇: 腾讯开源 tRPC:多语言、高性能 RPC 开发框架
下一篇: 从LLM到AIGC,开启AI时代寻宝之旅!
腾讯云开发者
腾讯云开发者 企业官方账号 企业官方账号
博客等级 码龄10年 6291粉丝 1962原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值