[C/C++]函数如何返回struct或class对象

本文写于我对C++尚不是很了解的时期，所以文中存在很多漏洞。为了避免浪费你的时间，请绕道！

所有的C、C++教科书都警告我们：不要通过函数来返回struct或 class对象，否则会造成内存复制以及复制构造函数的调用，降低性能。相信这句话已经成为了一个常识，大家都能牢记于心。然而，有时候我们不得不违反这个警告，例如，通过函数获取一个std::string对象（以个人的经验而言，这种情况是很常见的，我经常要通过函数创建一个新的对象）。不知道从什么时候起，当我面对这种情况的时候会通过引用来获取这个对象，像这样：

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个字节：

struct S {
	int Value;
};

S GetS(int value) {

	S s;
	s.Value = value;

	return s;
}

int wmain() {

	S s = GetS(10);
}

下面是GetS函数的部分汇编代码：

;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);的汇编代码：

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字节：

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函数的部分汇编代码：

;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);这一句的汇编代码：

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的大小如何，处理方式都是一样的。下面是例子：

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);的汇编代码：

push        0Ah      ;参数10入栈
lea         eax,[c]  ;取得局部变量c的地址
push        eax      ;将c的地址入栈
call        GetC     ;调用GetC
add         esp,8    ;释放参数空间

看上去清爽得多了。这里同样是将局部变量的地址作为隐含参数传递给被调用函数，但最后少了内存复制的操作。

下面是GetC的部分汇编代码：

;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对象基本上只需要调用一次复制构造函数即可。

下面再来看一种特殊情况：

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的部分汇编代码：

;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的语句产生的汇编代码：

;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版本的代码会经过优化，可能会消除那些降低性能的代码。当然啦，我们不能依赖于编译器的优化，因为不是任何情况都适合优化的。