这篇主要介绍返回值优化及移动构造(赋值)函数，后者是C++11中的知识点。本来是不准备写的，因为这些都比较基础且编译器为我们进行了一定的优化，但还是想记录下代码层面所发生的事情，且为最近相关C++11新知识点的学习进行简单总结。
在进行下面之前，需要了解什么是构造函数，默认构造函数，拷贝构造函数，赋值运算符，析构函数，以及什么情况下编译器会为类合成在编译器看来有用的构造(和其他几个)函数，这些知识可以参考《深度探索C++对象模型》和《(More)Effective C++》。
以最基本的类开始分析：
5 class CBase {
6 public:
7 CBase(const uint32_t m = 0) : m_count(m) {
8 std::cout << "CBase ctor" << std::endl;
9 }
10
11 CBase(const CBase& lhs) {
12 std::cout << "CBase copy ctor" << std::endl;
13 }
14
15 ~CBase() {
16 std::cout << "CBase dtor" << std::endl;
17 }
18 private:
19 uint32_t m_count;
20 };
21
22 CBase GetObjWithNoMove() {
23 return CBase();
24 }
25
26 int main(int argc, char** argv) {
27 CBase obj = GetObjWithNoMove();
28 return 0;
29 }
版本为7.3.0，直接g++ 编译，不加任何选项，输出为：
CBase ctor
CBase dtor
不考虑析构的代码，其他反汇编如下：
138 __Z16GetObjWithNoMovev:
139 100000d34: 55 pushq %rbp
140 100000d35: 48 89 e5 movq %rsp, %rbp
141 100000d38: 48 83 ec 10 subq $16, %rsp
142 100000d3c: 48 89 7d f8 movq %rdi, -8(%rbp)
143 100000d40: 48 8b 45 f8 movq -8(%rbp), %rax
144 100000d44: be 00 00 00 00 movl $0, %esi
145 100000d49: 48 89 c7 movq %rax, %rdi
146 100000d4c: e8 9b 00 00 00 callq 155
151 _main:
152 100000d57: 55 pushq %rbp
153 100000d58: 48 89 e5 movq %rsp, %rbp
154 100000d5b: 53 pushq %rbx
155 100000d5c: 48 83 ec 28 subq $40, %rsp
156 100000d60: 89 7d dc movl %edi, -36(%rbp)
157 100000d63: 48 89 75 d0 movq %rsi, -48(%rbp)
158 100000d67: 48 8d 45 ec leaq -20(%rbp), %rax
159 100000d6b: 48 89 c7 movq %rax, %rdi
160 100000d6e: e8 c1 ff ff ff callq -63 <__Z16GetObjWithNoMovev>
结合源码分析，汇编从152〜159似乎是在准备什么参数，然后调用GetObjWithNoMove，但是从源码并没有传实参，但这里为何会这样呢？就debug看一下这几行代码是什么玩意。
启动的时候，就直接定位在=> 0x0000000100000d67 <+16>: lea -0x14(%rbp),%rax把地址mov到rax中，查看下obj地址和rbp-0x20的值为：
(gdb) p obj
$4 = {m_count = 0}
(gdb) p &obj
$5 = (CBase *) 0x7ffeefbffa8c
(gdb) i r rbp
rbp 0x7ffeefbffaa0 0x7ffeefbffaa0
(gdb) x/w 0x7ffeefbffa8c
0x7ffeefbffa8c: 0x00000000
我们new一个对象的时候，先是分配一段足够的空间，再调用构造函数，再返回地址，当然后两步可以顺序对调，这在多线程中会有些问题，不讨论。
这里先分配一段空间，然后作为参数调用函数GetObjWithNoMove，再里面进行了构造函数的调用：
0x0000000100000d3c <+8>: mov %rdi,-0x8(%rbp)
=> 0x0000000100000d40 <+12>: mov -0x8(%rbp),%rax
0x0000000100000d44 <+16>: mov $0x0,%esi
0x0000000100000d49 <+21>: mov %rax,%rdi
0x0000000100000d4c <+24>: callq 0x100000dec
(gdb) si
CBase::CBase (this=0x100000000, m=32766) at move.cpp:7
7 CBase(const uint32_t m = 0) : m_count(m) {
(gdb) disassemble
Dump of assembler code for function CBase::CBase(unsigned int):
=> 0x0000000100000cb4 <+0>: push %rbp
0x0000000100000cb5 <+1>: mov %rsp,%rbp
0x0000000100000cb8 <+4>: sub $0x10,%rsp
0x0000000100000cbc <+8>: mov %rdi,-0x8(%rbp)
0x0000000100000cc0 <+12>: mov %esi,-0xc(%rbp)
0x0000000100000cc3 <+15>: mov -0x8(%rbp),%rax
0x0000000100000cc7 <+19>: mov -0xc(%rbp),%edx
0x0000000100000cca <+22>: mov %edx,(%rax)
是编译器为我们进行了优化？那原来的过程是怎么样的呢？重新编译并加选项-fno-elide-constructors并重新执行结果如下：
CBase ctor
CBase copy ctor
CBase dtor
CBase copy ctor
CBase dtor
CBase dtor
这里解释一下，然后再进行反汇编说明。在调用GetObjWithNoMove过程中，先进行了一次构造CBase()，此时打印第一行，然后调用拷贝构造作为返回值，打印第二行，执行完此条语句后，便进行析构，即打印第三行。GetObjWithNoMove结束返回一个临时对象，并以拷贝构造obj，即第四行，执行完后析构，最后析构obj。在这个过程中生成了两个临时对象，真正有用的是最后一次，这里没有涉及到复杂的对象构造和深拷贝。
以下是部分汇编代码，进行了旁注：
Dump of assembler code for function main(int, char**):
0x0000000100000cb5 <+0>: push %rbp
0x0000000100000cb6 <+1>: mov %rsp,%rbp
0x0000000100000cb9 <+4>: push %rbx
0x0000000100000cba <+5>: sub $0x28,%rsp
0x0000000100000cbe <+9>: mov %edi,-0x24(%rbp)
0x0000000100000cc1 <+12>: mov %rsi,-0x30(%rbp)
0x0000000100000cc5 <+16>: lea -0x14(%rbp),%rax
=> 0x0000000100000cc9 <+20>: mov %rax,%rdi
0x0000000100000ccc <+23>: callq 0x100000c50 <GetObjWithNoMove()>
0x0000000100000cd1 <+28>: lea -0x14(%rbp),%rdx
0x0000000100000cd5 <+32>: lea -0x18(%rbp),%rax
0x0000000100000cd9 <+36>: mov %rdx,%rsi
0x0000000100000cdc <+39>: mov %rax,%rdi
0x0000000100000cdf <+42>: callq 0x100000d8a //拷贝构造
0x0000000100000ce4 <+47>: lea -0x14(%rbp),%rax
0x0000000100000ce8 <+51>: mov %rax,%rdi
0x0000000100000ceb <+54>: callq 0x100000d96 //析构函数
0x0000000100000cf0 <+59>: mov $0x0,%ebx
0x0000000100000cf5 <+64>: lea -0x18(%rbp),%rax
0x0000000100000cf9 <+68>: mov %rax,%rdi
0x0000000100000cfc <+71>: callq 0x100000d96 //析构函数
Dump of assembler code for function GetObjWithNoMove():
=> 0x0000000100000c50 <+0>: push %rbp
0x0000000100000c51 <+1>: mov %rsp,%rbp
0x0000000100000c54 <+4>: push %rbx
0x0000000100000c55 <+5>: sub $0x28,%rsp
0x0000000100000c59 <+9>: mov %rdi,-0x28(%rbp)
0x0000000100000c5d <+13>: lea -0x14(%rbp),%rax
0x0000000100000c61 <+17>: mov $0x0,%esi
0x0000000100000c66 <+22>: mov %rax,%rdi
0x0000000100000c69 <+25>: callq 0x100000d90 //构造函数
0x0000000100000c6e <+30>: lea -0x14(%rbp),%rdx
0x0000000100000c72 <+34>: mov -0x28(%rbp),%rax
0x0000000100000c76 <+38>: mov %rdx,%rsi
0x0000000100000c79 <+41>: mov %rax,%rdi
0x0000000100000c7c <+44>: callq 0x100000d8a //拷贝构造
0x0000000100000c81 <+49>: nop
0x0000000100000c82 <+50>: lea -0x14(%rbp),%rax
0x0000000100000c86 <+54>: mov %rax,%rdi
0x0000000100000c89 <+57>: callq 0x100000d96 //析构函数
为了减少其中的构造成本，以下是编译器为这种代码优化的实现伪代码，即返回值优化，这个函数会被编译器转化为GetObjWithNoMove：
void GetObjWithNoMove(CBase& obj) {
obj.CBase::CBase();
//do something...
}
CBase obj;
GetObjWithNoMove(obj);
如果原来是这样的形式：
CBase GetObjWithNoMove() {
CBase tmp;
//do something...
return tmp;
}
还是会被优化成上面的形式，不过网上和书上有提及那种NRVO优化，用拷贝构造的形式，可能跟写法有关系：
void GetObjWithNoMove(CBase& obj) {
tmp.CBase::CBase();
obj.CBase::CBase(tmp); //copy ctor
tmp.CBase::~CBase();
return;
}
不过一般不会像上面这么写代码，再说编译器也为我们进行了优化。
具体可参考《深度探索C++对象模型》第二章的构造函数语意学。
不过这书比较老，最新版的C++11加了许多新的特性，比如移动构造，移动赋值。这些不是很难理解，我个人在工作中用C++11的机会不多，平时都只是从网上和书上，开源项目中学习到的使用方法。
以上涉及到万能引用，右值引用，和完美转发，这些可以看参考资料。
包括最新的emplace_back之类的接口直接在内存地址上构造而不是使用push_back之类的接口，后者可能生成临时对象等性能方面的原因。
当然使用emplace之类的需要自定义类带有构造函数，不然会报如下的错误：
/usr/local/Cellar/gcc@7/7.3.0/include/c++/7.3.0/ext/new_allocator.h:136:4: error: no matching function for call to 'CString::CString(int)'
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
move.cpp:16:5: note: candidate: CString::CString(const CString&)
CString(const CString& str) {
move.cpp:16:5: note: no known conversion for argument 1 from 'int' to 'const CString&'
还有些情况下不能使用emplace之类的，具体原因可能要在实践中去发现，比如参考中的会涉及，但是看的云里雾里的。
emplace_back部分源码如下：
template<class _Objty,
class... _Types>
static void construct(_Alloc&, _Objty * const _Ptr, _Types&&... _Args)
{ // construct _Objty(_Types...) at _Ptr
::new (const_cast<void *>(static_cast<const volatile void *>(_Ptr)))
_Objty(_STD forward<_Types>(_Args)...);
}
还是要多学习，和运用。
这篇没啥干货，后面会备忘C++11中的一些实现源码。
参考资料：
《深度探索C++对象模型》
《Effective Modern C++》
C++雾中风景9:emplace_back与可变长模板
网友评论