本文写于我对C++尚不是很了解的时期，所以文中存在很多漏洞。为了避免浪费你的时间，请绕道！
所有的C、C++教科书都警告我们：不要通过函数来返回struct或 class对象，否则会造成内存复制以及复制构造函数的调用，降低性能。相信这句话已经成为了一个常识，大家都能牢记于心。然而，有时候我们不得不违反这个警告，例如，通过函数获取一个std::string对象（以个人的经验而言，这种情况是很常见的，我经常要通过函数创建一个新的对象）。不知道从什么时候起，当我面对这种情况的时候会通过引用来获取这个对象，像这样：
|
1
2
|
std::string GetString();
std::string& str = GetString();
|
这样子给我的感觉会好一点，让我觉得对象的复制次数少了。然而这只是一种凭空猜想，没有经过任何证实。为了弄清楚这样做究竟会不会带来性能的提升，我决定研究一下函数是如何返回struct或class对象的。最好的研究途径当然是反汇编编译器生成的机器码了。
我的实验环境是Visual Studio 2010，所有代码都是Debug版本的，因为这样生成的机器码是最原始的，没有经过任何优化，可以显示出真实的情况。而Release版本的机器码经过了优化，已经是“面目全非”，所以本文不考虑该版本。另外，对于struct来说，Visual Studio 2010 的C编译器和C++编译器生成的代码是一样的，所以本文所有代码都通过C++编译器来编译。注意，使用不同的编译器可能会有不同的结果！
如何返回struct对象
首先来看一下函数如何返回struct对象。分两种情况：第一种情况是struct的大小是1字节、2字节或4个字节，可以放到al、ax或eax寄存器中；第二种情况是struct的大小不是上面提到的三个值，不能放到寄存器中（包括3个字节的）。要注意，这里所说的“大小”是指在内存中经过对齐后的大小，而不是定义的大小。如果没有特别说明，下文提到的大小也是指经过对齐后的大小。
第一种情况：struct可以放到寄存器中
下面是第一种情况的典型例子，struct的大小是4个字节：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
struct
S {
int
Value;
};
S GetS(
int
value) {
S s;
s.Value = value;
return
s;
}
int
wmain() {
S s = GetS(10);
}
|
下面是GetS函数的部分汇编代码：
|
1
2
3
4
5
6
|
;s.Value = value;
mov eax,dword ptr [value]
mov dword ptr [s],eax
;return s;
mov eax,dword ptr [s]
|
可以看到，s是直接通过eax来返回的，因为它的大小恰好可以放进eax寄存器中。
下面是S s = GetS(10);的汇编代码：
|
1
2
3
4
5
6
|
push 0Ah ;参数10入栈
call GetS (8D1019h) ;调用GetS函数
add esp,4 ;释放参数空间
mov dword ptr [ebp-0D4h],eax ;将返回值保存到临时空间
mov eax,dword ptr [ebp-0D4h] ;从临时空间里取出返回值
mov dword ptr [s],eax ;将返回值保存到s中
|
这些代码都很好理解，唯一让人疑惑的地方是，返回值不是直接保存到s中，而是先放到一块临时空间里（ebp-0D4h），然后再从这块临时空间转移到s中。为什么编译器要如此多此一举呢？这是因为存在“不接收返回值”的函数调用，例如：GetS(10);，它返回的struct不会保存到局部变量里，而是只保存到那块临时空间中。
上面的汇编代码确实验证了那句警告，即使struct可以像一个普通的int那样通过eax返回，也会稍微降低性能，因为执行了两条“多余”的指令，但我认为这样的开销还是可以接受的。对于大小为1个字节或2个字节的struct来说，生成的汇编代码跟上面的几乎一样，只不过返回值是通过al或ax来返回的。
第二种情况：struct不能放到寄存器中
下面是第二种情况的典型例子，struct的大小为12字节：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
struct
S {
int
Value1;
int
Value2;
int
Value3;
};
S GetS(
int
value) {
S s;
s.Value1 = value;
s.Value2 = value * 2;
s.Value3 = value * 3;
return
s;
}
int
wmain() {
S s = GetS(10);
}
|
下面是GetS函数的部分汇编代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
;s.Value1 = value;
mov eax,dword ptr [ebp+0Ch]
mov dword ptr [ebp-14h],eax
;s.Value2 = value * 2;
mov eax,dword ptr [ebp+0Ch]
shl eax,1
mov dword ptr [ebp-10h],eax
;s.Value3 = value * 3;
mov eax,dword ptr [ebp+0Ch]
imul eax,eax,3
mov dword ptr [ebp-0Ch],eax
;return s;
mov eax,dword ptr [ebp+8] ;取出第一个参数的值
mov ecx,dword ptr [ebp-14h] ;取出s.Value1
mov dword ptr [eax],ecx ;将s.Value1放到eax所指的内存中
mov edx,dword ptr [ebp-10h] ;取出s.Value2
mov dword ptr [eax+4],edx ;将s.Value2放到eax+4所指的内存中
mov ecx,dword ptr [ebp-0Ch] ;取出s.Value3
mov dword ptr [eax+8],ecx ;将s.Value3放到 eax+8所指的内存中
mov eax,dword ptr [ebp+8] ;将第一个参数作为返回值
|
重点看return s;这一句的汇编代码，它将局部变量s（ebp-14h）复制到了第一个参数（ebp+8）所指的内存中，然后将第一个参数作为返回值。等等，GetS不是只有一个参数吗？而且这个参数只是一个数值，而不是地址，这样做的话肯定会出错。再往上看看那几条赋值语句的汇编代码，或许就明白了：GetS的参数value实际上是ebp+0Ch，而不是ebp+8，也就是说，GetS实际上有两个参数！
再来看一下S s = GetS(10);这一句的汇编代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
push 0Ah ;参数10入栈
lea eax,[ebp-0E8h] ;取出临时空间的地址
push eax ;将临时空间的地址入栈
call GetS (51019h) ;调用GetS
add esp,8 ;释放参数空间
;接下来的6条指令是将返回的struct（ebp-0E8h）复制到另一块临时空间（ebp-0FCh）中
mov ecx,dword ptr [eax]
mov dword ptr [ebp-0FCh],ecx
mov edx,dword ptr [eax+4]
mov dword ptr [ebp-0F8h],edx
mov eax,dword ptr [eax+8]
mov dword ptr [ebp-0F4h],eax
;接下里的6条指令将临时空间（ebp-0FCh）中的数据复制到局部变量s（ebp-14h）中
mov ecx,dword ptr [ebp-0FCh]
mov dword ptr [ebp-14h],ecx
mov edx,dword ptr [ebp-0F8h]
mov dword ptr [ebp-10h],edx
mov eax,dword ptr [ebp-0F4h]
mov dword ptr [ebp-0Ch],eax
|
可以看到，GetS除了value这个显式定义的参数之外，还有一个隐含的参数，该参数是一个指向一块临时空间（ebp-0E8h）的地址，在GetS内部将要返回的struct复制到了这块临时空间中，然后再通过eax返回这块临时空间的地址。这样，通过两方的协作，完成了struct的返回。
接下来的指令仍然是在做“多余”的事情：将返回值复制到另一块临时空间（ebp-0FCh）中，再从临时空间复制到局部变量s（ebp-14h）中。综上所述，为了从函数中返回一个struct，需要三块内存空间：一块用来接收返回值，一块“多余”的临时空间，一块是局部变量的空间。另外还需要进行三次内存复制：一次是被调用函数复制返回值，另外两次是“多余”的复制。由此看出，返回一个不能容纳于寄存器中的struct，不仅浪费时间，也浪费空间！
如何返回class对象
虽然在C++中struct和class本质上是一样的，但为了加以区别，在下文中规定，class泛指含有复制构造函数的struct或class，而struct 泛指没有复制构造函数的struct或class（希望不会给你带来混乱）。你会看到，有没有复制构造函数会造成很大的不同。
返回class对象的行为比返回struct的行为简单得多，不论class的大小如何，处理方式都是一样的。下面是例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
class
C {
public
:
C() { }
C(
const
C& rhs) {
Value1 = rhs.Value1;
Value2 = rhs.Value2;
Value3 = rhs.Value3;
}
int
Value1;
int
Value2;
int
Value3;
};
C GetC(
int
value) {
C c;
c.Value1 = value;
c.Value2 = value * 2;
c.Value3 = value * 3;
return
c;
}
int
wmain() {
C c = GetC(10);
}
|
下面是C c = GetC(10);的汇编代码：
|
1
2
3
4
5
|
push 0Ah ;参数10入栈
lea eax,[c] ;取得局部变量c的地址
push eax ;将c的地址入栈
call GetC ;调用GetC
add esp,8 ;释放参数空间
|
看上去清爽得多了。这里同样是将局部变量的地址作为隐含参数传递给被调用函数，但最后少了内存复制的操作。
下面是GetC的部分汇编代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
;C c;
lea ecx,[c]
call C::C ;调用默认构造函数
;c.Value1 = value;
mov eax,dword ptr [value]
mov dword ptr [c],eax
;c.Value2 = value * 2;
mov eax,dword ptr [value]
shl eax,1
mov dword ptr [ebp-0Ch],eax
;c.Value3 = value * 3;
mov eax,dword ptr [value]
imul eax,eax,3
mov dword ptr [ebp-8],eax
;return c;
lea eax,[c]
push eax
mov ecx,dword ptr [ebp+8]
call C::C ;调用复制构造函数
mov eax,dword ptr [ebp+8]
|
重点还是在return c;这条语句上，它的汇编代码非常简洁，仅仅是调用传递进来的C对象的复制构造函数！假如复制构造函数中只进行一次内存复制的话，那么从函数中返回一个class对象只需要进行一次内存复制，也只需要一块内存空间，即局部变量所需的空间。也就是说，返回一个class对象基本上只需要调用一次复制构造函数即可。
下面再来看一种特殊情况：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
class
C {
public
:
C(
int
value) {
Value1 = value;
Value2 = value;
Value3 = value;
}
C(
const
C& rhs) {
Value1 = rhs.Value1;
Value2 = rhs.Value2;
Value3 = rhs.Value3;
}
int
Value1;
int
Value2;
int
Value3;
};
C GetC(
int
value) {
return
C(value);
}
int
wmain() {
C c = GetC(10);
}
|
在GetC函数中，直接在return语句中构造一个C对象并返回。可以猜想，这样的话只需要调用一次构造函数就可以返回class对象了。下面是GetC的部分汇编代码：
|
1
2
3
4
5
6
|
;return C(value);
mov eax,dword ptr [value]
push eax
mov ecx,dword ptr [ebp+8]
call C::C ;调用构造函数
mov eax,dword ptr [ebp+8]
|
果然如此，这种做法的效率更高，跟创建一个新的对象几乎没有什么区别（当然，函数调用的开销还是存在的）。
由此可以看出，通过函数来返回一个class对象比返回一个struct对象开销要小得多，不需要多余的内存空间，也不需要多余的复制内存操作。
通过引用来获取对象真的高效率吗？
好了，上面通过对函数如何返回struct或class对象进行了比较全面研究，是时候来回答本文开头提到的问题了。下面分别是通过引用来获取struct和class的语句产生的汇编代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
;S& s = GetS(10);
push 0Ah
lea eax,[ebp-0F4h]
push eax
call GetS
add esp,8
;下面6条指令将返回值（ebp-0F4h）复制到第一块临时空间（ebp-108h）
mov ecx,dword ptr [eax]
mov dword ptr [ebp-108h],ecx
mov edx,dword ptr [eax+4]
mov dword ptr [ebp-104h],edx
mov eax,dword ptr [eax+8]
mov dword ptr [ebp-100h],eax
;下面6条指令将第一块临时空间（ebp-108h）的数据复制到第二块临时空间（ebp-20h）
mov ecx,dword ptr [ebp-108h]
mov dword ptr [ebp-20h],ecx
mov edx,dword ptr [ebp-104h]
mov dword ptr [ebp-1Ch],edx
mov eax,dword ptr [ebp-100h]
mov dword ptr [ebp-18h],eax
;将第二块临时空间（ebp-20h）的地址赋值给局部变量s（ebp-0Ch）
lea ecx,[ebp-20h]
mov dword ptr [ebp-0Ch],ecx
;C& c = GetC(10);
push 0Ah
lea eax,[ebp-1Ch]
push eax
call GetC
add esp,8
;将临时空间（ebp-1Ch）的地址赋值给变量c
lea ecx,[ebp-1Ch]
mov dword ptr [c],ecx
|
通过与上文的汇编代码进行比较，发现使用引用后不仅没有减少指令，反而增加了两条指令，将临时空间的地址赋值给引用变量。所以得出结论，使用引用来获取对象的效率反而降低了！
总结
知道了函数如何返回struct或class对象，我得出下面的编程指导：
①对于大小为1字节、2字节或4字节的struct，可以通过函数来返回。
②对于大小不是1字节、2字节或4字节的struct，不要通过函数来返回。
③对于class，如果复制构造函数的工作量少，可以通过函数来返回；如果复制构造函数的工作量大，则不要通过函数返回。
④对于class，尽量通过在return语句中构造对象来返回。
⑤不要通过引用来获取函数返回的对象！
最后再说明一下，不同编译器的处理方式可能会不同，所以上面的指导不一定完全通用。另外，Release版本的代码会经过优化，可能会消除那些降低性能的代码。当然啦，我们不能依赖于编译器的优化，因为不是任何情况都适合优化的。
来自：http://www.cnblogs.com/zplutor/archive/2011/09/25/2190315.html
扫一扫
2733
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
