C/C++ 将自定义类或结构体作为返回值 复制构造函数触发问题 RVO机制

1.起因

一朋友问我了一段代码：

class Test {};

Test getOneObject()
{
    return Test();
}
int main()
{
    Test t = getOneObject();
    return 0;
}

问：上述代码的Test t = getOneObject()是不是会触发复制函数？
当我看到这个问题，我想起在C++ Primer Plus中作者提到在初始化时对象的赋值会触发复制构造函数，而非初始化阶段的赋值，则是通过operator=，那么上述的过程很明显是发生在初始化阶段，于是我推测在Test gtOneObject()中构造出一个Test对象之后通过复制构造函数将其复制给main::t，于是我回答一定会触发。

2.实践是检验真理的唯一标准

实验环境：WSL2 Ubuntu 20.04(x_86_64) g++ 9.4.0
于是我写出了下面的代码：

#include <bits/stdc++.h>

using namespace std;

class Test
{
public:
    static int cnt;
    Test()
    {
        cnt++;
        cout << cnt << ": In Test()" << endl;
    }
    Test(const Test &rhs)
    {
        cnt++;
        cout << cnt << ": In Test(const Test&)" << endl;
    }
};

int Test::cnt = 0;

Test getOneObject()
{
    return Test();
}
int main()
{
    Test t = getOneObject();
    return 0;
}

代码的输出如下：

1: In Test()

这意味着并没有调用复制函数，甚至只构造了一个对象，这显然是不符合常理的，因为按照常理来说，即使不调用复制函数在getOneObject()和main()的作用域中应该各有一个对象才对，不考虑赋值的情况下，应该至少调用两次构造函数。而上述的输出表名自始至终只有一个Test对象于是我将代码改进了一下，输出了对象的地址，核心代码如下：

Test getOneObject()
{
	Test t = Test();
	cout << &t << endl;
    return t;
}
int main()
{
    Test t = getOneObject();
    cout << &t << endl;
    return 0;
}

程序输出：

1: In Test()
0x7ffea24344d7
0x7ffea24344d7

可以看到两个对象的地址是一样的，这是很诡异的，这说明不同作用域的局部变量竟然用了同样的内存地址。

3. 踏破铁鞋无觅处 背后的原因 RVO机制

我的第一直觉是编译器做了优化，毕竟现代的编译器比我聪明多了，然后我将代码放到Compile Explorer上看了一下汇编指令：（下面代码只截取了关键地方）

getOneObject():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]
        nop
        mov     rax, QWORD PTR [rbp-8]
        leave
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    getOneObject()
        mov     eax, 0
        leave
        ret

通过汇编代码我发现了端倪，在main中有两行：

		lea     rax, [rbp-1]
        mov     rdi, rax

上述两条指令将一个地址复制给了rdi寄存器，而这个地址就是代码中main::t的地址，而在getOneObject()中：

        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]

可以看到将获取的地址最终放在rdi寄存器中，然后调用了构造函数，也就是说在getOneObject()中直接对main::t的地址进行了操作，这相当于传入了一个指针变量，于是我又写了下面的代码：

Test getOneObject()
{
    return Test();
}

void getOneObject(Test *tp)
{
    *tp = Test();
}

int main()
{
    Test t = getOneObject();
    getOneObject(&t);
    return 0;
}

将上述代码放入到Compile Explorer中得到：

getOneObject():
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax
        call    Test::Test() [complete object constructor]
        mov     rax, QWORD PTR [rbp-8]
        leave
        ret
getOneObject(Test*):
        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]
        nop
        leave
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    getOneObject()
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    getOneObject(Test*)
        mov     eax, 0
        leave
        ret

可以看到在main()中两个函数调用的汇编指令是一样的，同时可以看到两个getOneObject()函数中除了地址不一样整个逻辑都是一样的，这是不是说明编译器将需要复制的getOneObject()优化成了不需要复制函数的指针类型。
查阅资料我发现了RVO(Return Value Optimization)机制，该机制所做的事情就是将返回值为自定义对象的函数优化成指针调用形式，即发生了下面转化

Test t = getOneObject()
// convert to
Test t;
getOneObject(&t);

不得不说为了防止拷贝的开支，编译器也是绞尽脑汁。那么如何关闭该机制，以测试复制函数触发机制呢？
只需要编译时增加-fno-elide-constructors编译选项即可，通过禁止RVO机制得到的输出如下：

1: In Test()
2: In Test(const Test&)
3: In Test(const Test&)

但是此时竟然调用了两次复制构造函数，这又是为什么呢？
我们再来看一下代码：

Test getOneObject()
{
    return Test();
}
int main()
{
    Test t = getOneObject();
    return 0;
}

可以推断的是有一次复制构造函数的调用是由Test t = getOneObject()所触发的。而另一次构造函数的触发则是因为：此时要想要连接两个函数，则必须通过调用者的堆栈中的某一个地址，也就是main必须先在自己的堆栈中开辟一块空间将该空间作为返回值的存放位置，同时需要将该空间的地址传递给getOneObject()，后者在自己的空间中创建对象后，通过复制函数将对象复制到该地址，这也就触发了另一次复制函数。我们可以通过汇编指令来验证这一点：

getOneObject():
        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]
        mov     rax, QWORD PTR [rbp-24]
        leave
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    getOneObject()
        lea     rdx, [rbp-1]
        lea     rax, [rbp-2]
        mov     rsi, rdx
        mov     rdi, rax
        call    Test::Test(Test const&) [complete object constructor]
        mov     eax, 0
        leave
        ret