欢迎光临
我们一直在努力

深入理解 C++ 对象使用过程中的优化

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 赋值,再把这个返回值临时对象析构掉。所以把这三部给省掉了!!!

总结:创建对象,使用对象的时候,如果能优化,尽量按照优化规则去优化,这样才能大大减少对象背后函数的调用,减少函数调用开销,让程序效率更高。

赞(0)
未经允许不得转载:171主机测评 » 深入理解 C++ 对象使用过程中的优化
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址