从汇编看c++中的默认拷贝函数
《c++编程思想》上说一个类如果没有拷贝函数，那么编译器就会自动创建一个默认的拷贝函数。下面就让我们看一下真实的情况。
首先看一个简单的类X，这个类没有显示定义拷贝构造函数。c++源码如下:
class X { private: int i; int j; }; int main() { X x1;//先定义对象x1 X x2 = x1;//将x1拷贝给x2 }
下面是其汇编代码:
_main PROC ; 7 : int main() { push ebp mov ebp, esp sub esp, 16 ; 为对象x1，x2预留16byte的栈空间 ; 8 : X x1;//先定义对象x1 ; 9 : X x2 = x1;//将x1拷贝给x2 mov eax, DWORD PTR _x1$[ebp];将x1的首地址里面的内容给寄存器eax，也就将x1中的成员变量i的值给eax mov DWORD PTR _x2$[ebp], eax;将eax里面的值写入x2的首地址，也就是将eax里面的值写给x2的成员变量i mov ecx, DWORD PTR _x1$[ebp+4];将偏移x1首地址4byte的内存里面的值给寄存器eax，也就是将x1中的成员变量j的值给ecx mov DWORD PTR _x2$[ebp+4], ecx;将ecx里面的值写入偏移x2首地址4byte的内存里面，也就是将ecx里面的值写给x2的成员变量j ; 10 : } xor eax, eax mov esp, ebp pop ebp ret 0 _main ENDP
从汇编代码里面可以看出，根本没有函数被调用，所有的拷贝赋值都是通过寄存器与内存地址相互通信完成。和编译器提供默认构造函数一样，可以把这种情况看成是编译器提供了一个无用的拷贝构造函数。
那么，什么时候编译器才真正的提供默认拷贝构造函数，并且显示调用呢？
下面是一种情况，类X里面含有虚成员函数:
c++源码:
class X { private: int i; int j; public: virtual ~X() {}//虚析构函数 }; int main() { X x1;//先定义对象x1 X x2 = x1;//将x1拷贝给x2 }
由于这里只讨论拷贝函数，所以只看主函数main和拷贝函数里面的汇编代码:
下面是主函数main里面的汇编代码:
_main PROC ; 9 : int main() { push ebp mov ebp, esp sub esp, 24 ; 由于引入了虚函数，每个类所占的空间编程12byte 成员变量i，j8byte vptr指针4byte 因此这里为x1 x2预留24byte ; 10 : X x1;//先定义对象x1 lea ecx, DWORD PTR _x1$[ebp];获取x1的首地址，放入ecx，为调用构造函数的秘密参数传入，即this call ??0X@@QAE@XZ;调用构造函数 ; 11 : X x2 = x1;//将x1拷贝给x2 lea eax, DWORD PTR _x1$[ebp];获取x1的首地址，放入寄存器eax push eax;将eax压栈，作为拷贝构造函数的参数 lea ecx, DWORD PTR _x2$[ebp];获取x2的首地址，放入寄存器ecx，作为调用拷贝构造函数的秘密参数传入，即this call ??0X@@QAE@ABV0@@Z;调用拷贝构造函数 ; 12 : } lea ecx, DWORD PTR _x2$[ebp];获取x2的首地址，放入ecx寄存器，作为调用析构函数传入的秘密参数，即this call ??1X@@UAE@XZ ; 调用析构函数 lea ecx, DWORD PTR _x1$[ebp];获取x1的首地址，放入ecx寄存器，作为调用析构函数传入的秘密参数，即this ;析构的顺序与构建的顺序相反 call ??1X@@UAE@XZ ; 调用析构函数 xor eax, eax mov esp, ebp pop ebp ret 0 _main ENDP
可以看到，编译器为类X提供了默认的拷贝构造函数(非无用的默认拷贝构造函数)，并且显示调用。
由于一个类继承自继承自有虚函数成员的基类，使得它本身也含有虚函数成员，因此也就属于上一种情形。所以编译器在这种情况下，也会提供非无用的默认拷贝构造函数，并且能够显示调用。
下面是第二种情况，类Y继承自虚基类X
下面是c++源码:
class X { private: int i; }; class Y : public virtual X { private: int i; }; int main() { Y y; Y y1 = y; }
虚基类X和子类Y都没有显示定义拷贝构造函数
下面来看一下main函数中的汇编码:
; 12 : Y y; push 1;压入标志 避免重复调用虚基类的构造函数 在多重继承中有用 lea ecx, DWORD PTR _y$[ebp];将对象y的首地址给ecx(this指针) 作为隐含参数传给构造函数 call ??0Y@@QAE@XZ;调用对象y的构造函数 由于类Y继承自虚基类 编译器提供非无用的拷贝构造函数 ; 13 : Y y1 = y; push 1;压入标志 lea eax, DWORD PTR _y$[ebp];将对象y的首地址给eax，作为参数传递给拷贝构造函数 push eax;压入参数 lea ecx, DWORD PTR _y1$[ebp];将对象y1的首地址给ecx 作为隐含的参数传递给拷贝构造函数 call ??0Y@@QAE@ABV0@@Z;调用类Y的拷贝函数
可以看到，虽然虚基类X和子类Y都没显示定义拷贝构造函数，但是编译器还是为类Y提供了非无用的默认的拷贝构造函数
下面是类Y的拷贝构造函数汇编码:
??0Y@@QAE@ABV0@@Z PROC ; Y::Y, COMDAT ; _this$ = ecx push ebp mov ebp, esp sub esp, 8 mov DWORD PTR _this$[ebp], ecx;ecx存有y1对象的首地址，存入 cmp DWORD PTR _$initVBases$[ebp], 0;_$initVBases里面存的是调用拷贝构造函数之前存入的标志 ;如果标志为1 拷贝虚基类 如果标志为0 不拷贝虚基类，跳到标号$LN1@Y@2处执行 ;这里将标志和0做比较 je SHORT $LN1@Y@2 mov eax, DWORD PTR _this$[ebp];将y1对象首地址给eax mov DWORD PTR [eax], OFFSET ??_8Y@@7B@;将??_8Y@@7B@内存首地址写给y1对象首地址所指向的内存，即初始化vt_offset指针 cmp DWORD PTR ___that$[ebp], 0;将对象y的首地址值和0 比较 jne SHORT $LN4@Y@2;不等于0就跳到标号处执行 否则顺序执行 mov DWORD PTR tv79[ebp], 0;将0写入指定内存 jmp SHORT $LN5@Y@2;跳到标号处执行 $LN4@Y@2: mov ecx, DWORD PTR ___that$[ebp];将y对象首地址给ecx mov edx, DWORD PTR [ecx];获取y对象vt_offset指针所指向内存的首地址 mov eax, DWORD PTR ___that$[ebp];将y对象的首地址给eax add eax, DWORD PTR [edx+4];获取y对象中虚基类父对象相对于首地址处的vt_offset指针的偏移量，并和y对象首地址相加 算出y对象中虚基类父对象的首地址 mov DWORD PTR tv79[ebp], eax;将y对象中虚基类父对象首地址写入指定内存 $LN5@Y@2: mov ecx, DWORD PTR tv79[ebp];将y对象中虚基类父对象的首地址给ecx mov edx, DWORD PTR [ecx];将y对象中的虚基类父对象首地址值内容给edx 即将虚基类父对象中的成员变量i值给edx mov eax, DWORD PTR _this$[ebp];将y1对象的首地址给eax mov DWORD PTR [eax+8], edx;将edx的内容写给偏移y1对象首地址8byte处内存 这里拷贝y对象虚基类成员变量 $LN1@Y@2: mov ecx, DWORD PTR _this$[ebp];将y1对象的首地址给ecx mov edx, DWORD PTR ___that$[ebp];将y对象首地址给edx mov eax, DWORD PTR [edx+4];将偏移y对象首地址4byte处的内存内容给eax 即将y对象自己的成员变量i值给eax mov DWORD PTR [ecx+4], eax;将eax的内容写入偏移y1对象首地址4byte处的内存 即将eax的内容写给y1自己的成员变量i 这里拷贝y对象自己的成员变量 mov eax, DWORD PTR _this$[ebp] mov esp, ebp pop ebp ret 8 ??0Y@@QAE@ABV0@@Z ENDP
下面是第三种情形，类X继承自类Y，类Y有显示定义的拷贝构造函数，而类没有提供拷贝构造函数：
下面是c++源码：
class Y { private: int j; public: Y(const Y& y) {} Y() {};//必须为Y提供默认的构造函数，否则编译出错 }; class X : public Y { private: int i; int j; }; int main() { X x1;//先定义对象x1 X x2 = x1;//将x1拷贝给x2 }
下面是mian函数汇编代码:
; 16 : int main() { push ebp mov ebp, esp sub esp, 24 ; 为x1 x2预留24byte空间 ; 17 : X x1;//先定义对象x1 lea ecx, DWORD PTR _x1$[ebp];获取x1的首地址，作为隐含参数传递给构造函数 call ??0X@@QAE@XZ;//调用编译器为类X提供的默认构造函数 ; 18 : X x2 = x1;//将x1拷贝给x2 lea eax, DWORD PTR _x1$[ebp];获取x1的首地址，传给寄存器eax push eax;将eax压栈，作为调用类X的拷贝构造函数的参数 lea ecx, DWORD PTR _x2$[ebp];获取x2的首地址，作为调用类X的拷贝函数的隐含参数 call ??0X@@QAE@ABV0@@Z;调用编译器提供的默认拷贝构造函数 ; 19 : } xor eax, eax mov esp, ebp pop ebp ret 0
下面是类X的拷贝构造函数的汇编码:
??0X@@QAE@ABV0@@Z PROC ; X::X, COMDAT ; _this$ = ecx push ebp mov ebp, esp push ecx mov DWORD PTR _this$[ebp], ecx;ecx里面有x2的首地址 mov eax, DWORD PTR ___that$[ebp];将x1的首地址给eax push eax;将eax的首地址压栈，作为调用父类拷贝构造函数的参数 mov ecx, DWORD PTR _this$[ebp];将x2的首地址给ecx，作为隐含参数传给父类的拷贝构造函数 call ??0Y@@QAE@ABV0@@Z ; 调用父类拷贝构造函数 mov ecx, DWORD PTR _this$[ebp];获取x2的首地址给ecx mov edx, DWORD PTR ___that$[ebp];获取x1的首地址给edx mov eax, DWORD PTR [edx+4];将偏移x1首地址4byte处的内存里面的值写给eax，即将x1中子类成员变量i的值写给eax，因为x1的首地址处存放的是父类成员变量i，其值 ;由父类拷贝构造函数负责拷贝给x2 mov DWORD PTR [ecx+4], eax;将eax的值写入偏离x2首地址4byte处的内存里面，即将eax的值写入x2中子类成员变量i，因为x2的首地址处存放父类成员变量i，其值 ;由父类拷贝构造函数负责拷贝 mov ecx, DWORD PTR _this$[ebp];将x2的首地址给ecx mov edx, DWORD PTR ___that$[ebp];将x1的首地址给edx mov eax, DWORD PTR [edx+8];将偏移x1首地址8byte处的内存里面的值给eax，即将x1中子类成员变量j的值给eax mov DWORD PTR [ecx+8], eax;将eax的值写入偏移x2首地址8byte的内存里面，即将eax的值写入x2子类成员j中 mov eax, DWORD PTR _this$[ebp];将x2的首地址给eax，作为返回值。构造函数总是返回对象首地址 mov esp, ebp pop ebp ret 4 ??0X@@QAE@ABV0@@Z ENDP
从汇编码中可以看到，编译器确实为类X提供了默认的拷贝构造函数，并且进行了显示调用。而且在调用类X的拷贝构造函数中，首先调用父类的拷贝构造函数，拷贝父类中的成员变量，然后再拷贝子类中的成员变量。
下面是父类Y中的拷贝构造函数汇编码:
??0Y@@QAE@ABV0@@Z PROC ; Y::Y, COMDAT ; _this$ = ecx ; 5 : Y(const Y& y) {} push ebp mov ebp, esp push ecx;//这里压栈的目的是为隐含传给父类拷贝函数的this(即x2的首地址) mov DWORD PTR _this$[ebp], ecx;ecx里面含有x2的首地址(即this),放入刚才的预留空间 mov eax, DWORD PTR _this$[ebp];将x2的首地址写入eax，作为返回值。构造函数总是返回对象首地址 mov esp, ebp pop ebp ret 4 ??0Y@@QAE@ABV0@@Z ENDP ; Y::Y _TEXT ENDS
从汇编吗可以看到，由于父类自己显示定义了拷贝构造函数，编译器只是负责调用而已，并不提供像上面子类X里面默认拷贝构造函数的拷贝功能，即并不拷贝父类成员变量i。因为，在c++源码里面，父类拷贝构造函数本身就是空函数，什么也不做。
如果子类X 父类Y都不提供拷贝构造函数，情形有时怎样的呢？
下面是c++源码:
class Y { private: int j; }; class X : public Y { private: int i; int j; }; int main() { X x1;//先定义对象x1 X x2 = x1;//将x1拷贝给x2 }
下面是对应的汇编码：
_main PROC ; 12 : int main() { push ebp mov ebp, esp sub esp, 24 ; 为x1 x2预留24byte空间 ; 13 : X x1;//先定义对象x1 ; 14 : X x2 = x1;//将x1拷贝给x2 mov eax, DWORD PTR _x1$[ebp];获取x1的首地址里面的值，存入eax,即获取x1父类成员变量i的值写给eax mov DWORD PTR _x2$[ebp], eax;将eax的值写入x2的首地址指向的内存，即将eax的值写给x2中的父类成员变量i mov ecx, DWORD PTR _x1$[ebp+4];获取偏移x1首地址4byte处的内存里面的值，写入ecx，即获取x1子类成员变量i的值写给ecx mov DWORD PTR _x2$[ebp+4], ecx;将ecx的值写入偏移x2首地址4byte处的内存里面，即将ecx的值写给x2中子类成员变量i mov edx, DWORD PTR _x1$[ebp+8];获取偏移x1首地址8byte处的内存里面的值，写入edx，即获取x1子类成员变量j的值写给edx mov DWORD PTR _x2$[ebp+8], edx;将edx的值写入偏移x2首地址8byte处的内存里面，即将edx的值写入x2子类成员变量j ; 15 : } xor eax, eax mov esp, ebp pop ebp ret 0 _main ENDP
可以看到，编译器执行了拷贝过程，但是提供的是像刚开始的无用的默认拷贝构造函数，无论是拷贝父类成员变量，还是子类成员变量，都没有函数的调用。
下面看第四种情况，类X含有类Y的成员变量，类Y的成员变量有拷贝构造函数。
c++源码如下:
class Y { private: int j; public: Y(const Y& y) {} Y() {}//必须为Y提供默认的构造函数，否则编译报错 }; class X { private: int i; int j; Y y; }; int main() { X x1;//先定义对象x1 X x2 = x1;//将x1拷贝给x2 }
下面是main函数中的汇编码:
_main PROC ; 16 : int main() { push ebp mov ebp, esp sub esp, 24 ; 为x1 x2预留24byte的空间 ; 17 : X x1;//先定义对象x1 lea ecx, DWORD PTR _x1$[ebp];获取x1的首地址，作为隐含参数传递给构造函数 call ??0X@@QAE@XZ;调用构造函数 ; 18 : X x2 = x1;//将x1拷贝给x2 lea eax, DWORD PTR _x1$[ebp];获取x1的首地址，放入寄存器eax push eax;将eax压栈，为作为参数传递给编译器提供的默认拷贝构造函数 lea ecx, DWORD PTR _x2$[ebp];获取x2的首地址，作为隐含参数传递给编译器提供的默认拷贝构造函数 call ??0X@@QAE@ABV0@@Z;调用拷贝构造函数 ; 19 : } xor eax, eax mov esp, ebp pop ebp ret 0 _main ENDP
下面是编译器为类X提供的默认拷贝构造函数的汇编码:
??0X@@QAE@ABV0@@Z PROC ; X::X, COMDAT ; _this$ = ecx push ebp mov ebp, esp push ecx;压栈的目的是为this(即x2的首地址)预留空间 mov DWORD PTR _this$[ebp], ecx;ecx里面含有x2的首地址，放入刚才预留的空间里面 mov eax, DWORD PTR _this$[ebp];将x2的首地址给eax mov ecx, DWORD PTR ___that$[ebp];将x1的首地址给ecx mov edx, DWORD PTR [ecx];将x1的首地址的内容写入edx，即将x1中的成员变量i写入edx mov DWORD PTR [eax], edx;将edx的值写入x2的首地址，即将edx的值写入x2的成员变量i mov eax, DWORD PTR _this$[ebp];将x2的首地址写入寄存器eax mov ecx, DWORD PTR ___that$[ebp];将x1的首地址写入寄存器ecx mov edx, DWORD PTR [ecx+4];将偏移x1首地址4byte处的内存里面的值写入edx，即将x1的成员变量j的值写入edx mov DWORD PTR [eax+4], edx;将edx的值写入偏移x2首地址4byte处的内存，即将edx的值写入x2的成员变量j mov eax, DWORD PTR ___that$[ebp];将x1的首地址存入寄存器eax add eax, 8;//将x1的首地址加8，得到x1中成员对象y所处的地址，放入eax中 push eax;将eax的值压栈，作为调用成员变量y的拷贝函数的参数 mov ecx, DWORD PTR _this$[ebp];将x2的首地址存入寄存器ecx add ecx, 8;将x2的首地址加8，得到x2中成员对象y所在地址，放入ecx，这个地址作为隐含的参数传给成员变量函数的拷贝构造函数 call ??0Y@@QAE@ABV0@@Z ; 调用成员对象y的拷贝构造函数 mov eax, DWORD PTR _this$[ebp];将x2的首地址放入eax，作为返回值。构造函数总是返回对象的首地址 mov esp, ebp pop ebp ret 4 ??0X@@QAE@ABV0@@Z ENDP
从汇编吗可以看到，调用类X拷贝构造函数的时候，先将x1中的成员变量i，j拷贝到x2中，然后才是调用成员对象y的拷贝构造函数拷贝y中的成员变量。这和继承不同，在继承中，总是先调用父类的拷贝构造函数，再进行子类中的拷贝。这说明，对于这种包含成员对象的情况，成员对象的拷贝函数调用时机与他们定义的位置有关。在这里，类X的成员对象y在成员变量i，j之后定义，因此，它的拷贝构造函数要等拷贝完i，j之后才会被调用。
下面是类Y中的拷贝构造函数汇编代码:
??0Y@@QAE@ABV0@@Z PROC ; Y::Y, COMDAT ; _this$ = ecx ; 6 : Y(const Y& y) {} push ebp mov ebp, esp push ecx;压栈ecx的目的是为了存放this(x2中成员对象y的首地址)预留空间 mov DWORD PTR _this$[ebp], ecx;ecx里面有x2中成员对象y的首地址，放入刚才的预留空间 mov eax, DWORD PTR _this$[ebp];将x2中成员变量首地址放入eax，作为返回值。构造函数总是返回对象首地址 mov esp, ebp pop ebp ret 4 ??0Y@@QAE@ABV0@@Z ENDP
从代码中可以看到，由于类Y显示定义了拷贝构造函数，编译器也只是负责显示调用，并没有提供任何的拷贝功能。因为在类Y中，拷贝构造函数就是被定义成了一个空函数
和继承一样，如果成员对象也没有拷贝构造函数呢？
下面是c++源码:
class Y { private: int j; }; class X { private: int i; int j; Y y; }; int main() { X x1;//先定义对象x1 X x2 = x1;//将x1拷贝给x2 }
下面是对象的汇编码:
_main PROC ; 14 : int main() { push ebp mov ebp, esp sub esp, 24 ; 00000018H ; 15 : X x1;//先定义对象x1 ; 16 : X x2 = x1;//将x1拷贝给x2 mov eax, DWORD PTR _x1$[ebp];将x1中首地址的内容写入eax，即将x1中的成员变量值i写入eax mov DWORD PTR _x2$[ebp], eax;将eax的值写入x2的首地址处，即将eax的值写入x2的成员变量i mov ecx, DWORD PTR _x1$[ebp+4];将偏移x1首地址4byte处的内存里面的内容写入ecx，即将x1中成员变量j的值写入ecx mov DWORD PTR _x2$[ebp+4], ecx;将ecx的值写入偏移x2首地址4byte处的内存，即将ecx的值写入x2中成员变量j mov edx, DWORD PTR _x1$[ebp+8];将偏移x1首地址8byte处(这里是x1成员对象y的首地址)的内存值写入edx，即将x1中成员对象y中的成员变量i值写入edx mov DWORD PTR _x2$[ebp+8], edx;将edx的值写入偏移x2首地址8byte处(这里是x2成员对象y的首地址)的内存里面，即将edx的值写入x2中成员对象y的成员变量i里面
从汇编吗可以看出，编译器在这种情况下任然只是提供无用的默认拷贝构造函数，即没有显示的函数调用，只是用寄存器和内存之间的通信完成拷贝过程
综合上面的分析，可以看到：
对于一个类，如果它没有显示定义拷贝构造函数，编译器并不总是提供非无用的默认拷贝构造函数，除非:
1 该类包含虚函数成员函数(包括继承自虚基类或者继承的基类中有虚函数成员),这时编译器提供为该类提供非无用的默认拷贝构造函数
2 该类继承自虚基类(不管虚基类有没有显示定义拷贝构造函数，编译器都会为该类提供一个非无用的默认拷贝构造函数)
2 该类继承自一个基类，而基类含有自定义的拷贝函数，这时编译器为该类提供非无用的默认拷贝构造函数。(如果基类本身没有定义拷贝构造函数，但是编译器会为基类提供一个非无用的默认拷贝构造函数，也属于这种情况。也就是说，基类只要含有一个非无用的拷贝构造函数就行，不管这个非无用的拷贝构造函数是自定义的，还是编译器提供的)
3 该类包含一个成员对象，而该成员对象有自定的拷贝构造函数，这时编译器为该类提供非无用的默认拷贝构造函数。(如果成员对象本身没有定义拷贝构造函数，但是编译器会为成员对象提供一个非无用的默认拷贝构造函数，也属于这种情况。也就是说，成员对象只要包含一个非无用的拷贝构造函数就行，不管这个非无用的拷贝构造函数时自定义的，还是编译器提供的。这中情况和上一种类似).
并且，如果一个类自定义了一个拷贝构造函数，编译器只是负责调用，不会额外提供任何拷贝过程；而对于编译器提供的默认拷贝函数，不管是无用的，还是非无用的，都仅仅只是位拷贝.
