1.问题分析
我们先来看一段示例代码:
#include <iostream>
using namespace std;
class Test
{
public:
Test(int data = 10) : ma(data) { cout << "Test(int)" << endl; }
~Test() { cout << "~Test()" << endl; }
Test(const Test& t) : ma(t.ma) { cout << "Test(const Test&)" << endl; }
Test& operator=(const Test& t)
{
cout << "operator=" << endl;
ma = t.ma;
return *this;
}
int getDate() const
{
return ma;
}
private:
int ma;
};
Test getObject(Test t)
{
int val = t.getDate();
Test tmp(val);
return tmp;
}
int main()
{
Test t1;
Test t2;
t2 = getObject(t1);
return 0;
}
结合我之前的文章:C++ 对象使用过程中,背后都调用了哪些方法
来分析这段代码背后调用了哪些方法,我们来分析一下:
/*
抽线创建两个对象: t1 和 t2
打印 Test(int) Test(int)
之后会调用函数 getObject 传入参数 t1, 但是由于函数是值传递, 接着
会将 t1 拷贝构造给函数 main 栈帧上的参数 t, 打印 Test(const Test&),
之后又创建了一个临时对象 tmp, 打印 Test(int), 由于 tmp 是临时对象, getObject
函数结束后,这个临时对象就要被析构,并且栈帧回退, 这个临时对象 tmp 也销毁了,
所以为了带出返回值, 会在 main 函数的栈帧上开辟一块空间, 进行拷贝构造, 在 main
上也创建了一个临时对象,所以打印 Test(const Test&)。
后面出函数 getObject, 会将 tmp, t 依次析构掉, 之后由于 t2 已经存在, 所以会覅用
赋值重载函数,打印: operator=
最后 main函数 结束, 析构临时对象和 t2, t1, 所以打印:
~Test() 临时对象的析构
~Test() t2 的析构
~Test() t1 的析构
那么整个过程就结束了
*/
Test t1;
Test t2;
t2 = getObject(t1);
我们再从汇编指令的角度去看一下 getObject 函数的调用过程是怎样的,去深层次理解一下:
Test t1;
007C2985 push 0Ah // 压默认参数10
007C2987 lea ecx,[t1] // 取出 t1 的地址放进 ecx, 作为构造函数的 this 指针
007C298A call Test::Test (07C1415h) //调用构造函数,在 t1 这块内存上构造对象
007C298F mov dword ptr [ebp-4],0 // 这是 VS Debug 模式下的对象构造状态标记,用来异常时知道哪些对象已经构造成功, 需要析构 不用太关心
Test t2;
007C2996 push 0Ah
007C2998 lea ecx,[t2]
007C299B call Test::Test (07C1415h)
007C29A0 mov byte ptr [ebp-4],1
t2 = getObject(t1);
// ——— 先构造 getObject 的形参 t ————-
007C29A4 push ecx // push ecx 这里主要是为了在栈上腾出 sizeof(Test) 大小的空间, Test 只有一个 int ma,所以大小是 4 字节
007C29A5 mov ecx,esp // 这句等于 ecx = 形参 t 的地址, MSVC 32 位下通常用 ecx 传 this
007C29A7 mov dword ptr [ebp-0ECh],esp
007C29AD lea eax,[t1] // 把 t1 的地址放入寄存器 eax 中
007C29B0 push eax // eax压栈作为拷贝构造函数的参数
// 到这里调用拷贝构造的两个参数就具备了: 1.this 指针 2.参数地址
007C29B1 call Test::Test (07C11CCh) // 调用拷贝构造 注意这里的地址和之前创建对象 t2, t1的就不一样了
// ————————————————
// ——— 再构造 getObject 的返回值临时对象 ——
007C29B6 lea ecx,[ebp-0F8h] // [ebp-0F8h] 就是 main 给 getObject 准备的返回值临时对象空间
007C29BC push ecx // 可以理解为把返回值临时对象空间的地址传给 getObject
// 所以调用 getObject 之前,栈上传了 形参 t 和 main 给 getObject 准备的返回值临时对象空间地址
007C29BD call getObject (07C11A9h)
// ————————————————
// 清理参数 这里清理两个参数 所以栈顶指针向下移动两次, 每次 4 个字节
// 清理掉的是: 1.之前压入的 main 栈帧临时对象的地址 2.参数对象 t
007C29C2 add esp,8
007C29C5 mov dword ptr [ebp-10Ch],eax
007C29CB mov edx,dword ptr [ebp-10Ch]
007C29D1 mov dword ptr [ebp-110h],edx
007C29D7 mov byte ptr [ebp-4],2
007C29DB mov eax,dword ptr [ebp-110h]
//下面开始执行 t2 = getObject(t1);
007C29E1 push eax //临时对象地址压栈
007C29E2 lea ecx,[t2] 给 operator= 准备 this 指针
007C29E5 call Test::operator= (07C126Ch)
007C29EA mov byte ptr [ebp-4],1
007C29EE lea ecx,[ebp-0F8h]
007C29F4 call Test::~Test (07C131Bh) // 析构临时对象
007C29F9 nop
我们再看一下函数 getObject 内部做的事情:
// 我没看下面这两句做的事情
Test tmp(val); // 在 getObject 的栈帧上构造一个对象 tmp
007C27F1 mov eax,dword ptr [val]
007C27F4 push eax // 压参数,把 val 作为参数传给构造函数
007C27F5 lea ecx,[tmp] // 准备 tmp 的 this 指针
007C27F8 call Test::Test (07C1415h)
007C27FD mov byte ptr [ebp-4],1
return tmp;
007C2801 lea eax,[tmp]
007C2804 push eax // 压参数,把对象 tmp 的地址作为拷贝构造函数的参数
/*
准备 this 指针,这里的 [ebp + 8] 就是之前在 main 中给函数 getObject 准备的返回值空间
也就是这里压的 ecx :
007C29B6 lea ecx,[ebp-0F8h]
007C29BC push ecx
*/
007C2805 mov ecx,dword ptr [ebp+8]
// 这里调用拷贝构造的两个参数也准备好了: 1.this指针 2.tmp 的地址
007C2808 call Test::Test (07C11CCh)
007C280D mov ecx,dword ptr [ebp-0ECh]
007C2813 or ecx,1
007C2816 mov dword ptr [ebp-0ECh],ecx
007C281C mov byte ptr [ebp-4],0
// ——————— 析构tmp ——————
007C2820 lea ecx,[tmp]
007C2823 call Test::~Test (07C131Bh)
// ————————————————
007C2828 mov dword ptr [ebp-4],0FFFFFFFFh
// ————– 析构 main 栈帧上的参数对象 t —–
007C282F lea ecx,[t]
007C2832 call Test::~Test (07C131Bh)
// ————————————————
007C2837 nop
007C2838 mov eax,dword ptr [ebp+8] // 用寄存器返回 main 战阵上蓝碎星的地址
那么我们可以看出这整个过程是调用了 11个函数的:
Test(int)
Test(int)
Test(const Test&)
Test(int)
Test(const Test&)
~Test()
~Test()
operator=
~Test()
~Test()
~Test()
比较新的 VS 版本会自动进行优化,如果你和我同样的代码少了两个函数的调用,那么就是开启了优化,先把他关闭,方便我们学习,关闭的方法如下:右击你的项目 -> 点击属性 -> 找到 C/C++ -> 命令行 -> 添加 /Zc:nrvo- 如图:
这样就会把一些优化去掉。
2.优化策略
我们一一来看如何进行优化:
第一点,我们试试把参数的传递从【值传递】改成【引用传递】,代码如下:
// 其它代码不变, 如果你不想在这个函数内去改变传入的对象,可以考虑加 const 写成 const Test &t
Test getObject(Test &t)
{
int val = t.getDate();
Test tmp(val);
return tmp;
}
/*
打印结果:
引用传递 值传递
Test(int) Test(int)
Test(int) Test(int)
Test(int) Test(const Test&)
Test(const Test&) Test(int)
~Test() Test(const Test&)
operator= ~Test()
~Test() ~Test()
~Test() operator=
~Test() ~Test()
~Test()
~Test()
*/
从打印结果我们可以看出,这里一下子就少了两个函数的调用:也就是形参的拷贝口中与析构。
再来分析一下原因:值传递,必须在 main 函数的栈帧上拷贝构造一个形参对象 t,出了 getObject 函数的作用域,getObject 的参数区就要被清理,此时 t 也在其中,所以要调用他的析构函数,后把 t 所占用的栈空间回收,那么引用传递呢?引用传递的本质是传地址,只需把对象 t1 的地址传过去即可。
可以从汇编代码层面去验证一下:
t2 = getObject(t1); // 这段汇编也没有调用拷贝构造了
00952984 lea eax,[t1] // 这里直接把 t1 的地址取出来, 没有像之前一样还给参数对象 t 准备了空间
00952987 push eax
// 准备返回值临时对象(main栈帧上的)的地址作为 this 指针, 给后续调用拷贝构造用,也相当把这块的地址作为一个参数传给 getObject 函数了
00952988 lea ecx,[ebp-0ECh]
0095298E push ecx
0095298F call getObject (0951456h)
00952994 add esp,8
00952997 mov dword ptr [ebp-100h],eax
0095299D mov edx,dword ptr [ebp-100h]
009529A3 mov dword ptr [ebp-104h],edx
009529A9 mov byte ptr [ebp-4],2
009529AD mov eax,dword ptr [ebp-104h]
009529B3 push eax
009529B4 lea ecx,[t2]
009529B7 call Test::operator= (0951267h)
009529BC mov byte ptr [ebp-4],1
009529C0 lea ecx,[ebp-0ECh]
009529C6 call Test::~Test (0951316h)
009529CB nop
第二点,我们在 getObject 返回对象的时候,不用先创建一个临时对象 tmp 再返回,可以直接像下面这样:
Test getObject(const Test &t)
{
int val = t.getDate();
return Test(val);
}
int main()
{
Test t1;
Test t2;
t2 = getObject(t1);
return 0;
}
/*
打印结果:
Test(int)
Test(int)
Test(int)
operator=
~Test()
~Test()
~Test()
*/
从打印结果可以看出:这里又少了两个函数的调用,也就是 tmp 的构造与析构,那么有人会问,
return Test(val);
返回的这个临时对象不也得在 getObject 这个函数的栈帧上先构造出来吗,然后拷贝构造到 main 函数栈帧上,出了函数的作用域再析构吗?这里是不会的,就要就按我之前的那篇文章,上面给了链接,它的优化原理就是,如果用临时对象去拷贝构造一个新对象,那么就不会创建这个临时对象,而是直接在去构造这个新对象!!!
所以这里又少了两个函数的调用,下面的汇编指令也能体现出来:
return Test(val);
00261D7B mov eax,dword ptr [val]
00261D7E push eax
00261D7F mov ecx,dword ptr [ebp+8] // main函数准备的临时对象地址作为 this 指针
00261D82 call Test::Test (0261415h) // 调用拷贝构造
00261D87 mov ecx,dword ptr [ebp-0D4h]
00261D8D or ecx,1
00261D90 mov dword ptr [ebp-0D4h],ecx
00261D96 mov eax,dword ptr [ebp+8]
第三,接收返回值是对象的函数调用的时候,优先按初始化的方式接收,不要按赋值的方式接收
代码改成下面这样:
Test getObject(const Test &t)
{
int val = t.getDate();
return Test(val);
}
int main()
{
Test t1;
Test t2 = getObject(t1);
return 0;
}
/*
打印结果:
Test(int)
Test(int)
~Test()
~Test()
*/
可以从结果看出来,这里比之前又少了三个函数的调用!!!
再来分析一下原因,直接从汇编代码上看吧:
// main
Test t2 = getObject(t1);
00E62906 lea eax,[t1] // 取 t1 的地址作为 getObject 的参数
00E62909 push eax // 参数压栈
00E6290A lea ecx,[t2] // 取 t2 的地址作为 this 指针
00E6290D push ecx // 参数压栈
00E6290E call getObject (0E61465h)
00E62913 add esp,8
// getObject
return Test(val);
00E626EB mov eax,dword ptr [val]
00E626EE push eax
// 最值得注意的就是这里的 [ebp + 8] 是谁的内存呢? 答案是 t2 的
00E626EF mov ecx,dword ptr [ebp+8]
// 直接在 t2 空间上进行拷贝构造!!!
00E626F2 call Test::Test (0E61415h)
00E626F7 mov ecx,dword ptr [ebp-0D4h]
00E626FD or ecx,1
00E62700 mov dword ptr [ebp-0D4h],ecx
00E62706 mov eax,dword ptr [ebp+8]
所以还是之前的那种优化,你返回的是临时对象,用来拷贝构造一个新对象,那么临时对象就不会产生了,新对象会按照临时对象的构造方式去构造这个新对象。但是呢,现在这种优化,会直接在 t2 的空间上拷贝构造一个新对象,而不是先构造返回值临时对象,再给对象 t2 赋值,再把这个返回值临时对象析构掉。所以把这三部给省掉了!!!
总结:创建对象,使用对象的时候,如果能优化,尽量按照优化规则去优化,这样才能大大减少对象背后函数的调用,减少函数调用开销,让程序效率更高。


![P11246 [GESP202409 六级] 小杨和整数拆分-171主机测评](https://www.171host.com/wp-content/uploads/2026/11/20261108100631-6af049a75855c-220x150.png)

