从逆向分析角度看C++拷贝构造函数

一段C++代码：

//: HowMany_2.cpp
#include <iostream>

using namespace std;

class HowMany {
  static int objectCount;
  
public:
  HowMany() {
    ++objectCount;
    print("HowMany()");
  }
  ~HowMany() {
    --objectCount;
    print("~HowMany()");
  }
  HowMany(const HowMany& h) {
    ++objectCount;
    print("HowMany(const HowMany&)");
  }
  
  void print(const char ss[]) {
    cout << ss << ": ";
    cout << "objectCount = " << objectCount << endl;
    return ;
  }
};

int HowMany::objectCount = 0;

HowMany f(HowMany x) {
  x.print("x argument inside f()");
  cout << "Return From f()" << endl;
  return x;  // 有返回值 x
}

int main() {
  {
    HowMany h;
    cout << "Entering f()" << endl;
    HowMany h2 = f(h);
  }
  return 0;
} ///:~

Assembly Code：

38:   int main() {
39:     {
40:       HowMany h;
004017FD   lea         ecx,[h]					; [h] 为对象 h 的内存地址
00401800   call        @ILT+685(HowMany::HowMany) (004012b2)	; 调用构造函数
00401805   mov         dword ptr [ebp-4],0
41:       cout << "Entering f()" << endl;
0040180C   push        offset @ILT+200(std::endl) (004010cd)
00401811   push        offset string "Entering f()" (0046f090)
00401816   push        offset std::cout (0047ce98)
0040181B   call        @ILT+660(std::operator<<) (00401299)	; 题外话，观察一下进栈顺序
00401820   add         esp,8
00401823   mov         ecx,eax
00401825   call        @ILT+480(std::basic_ostream<char,std::char_traits<char> >::operator<<) (004011e5)
42:       HowMany h2 = f(h);
0040182A   push        ecx
0040182B   mov         ecx,esp					; 当前 ESP 所指的栈块作为临时对象Temp的内存地址
0040182D   mov         dword ptr [ebp-18h],esp
00401830   lea         eax,[h]					
00401833   push        eax					; 将h的内存地址[h]压入堆栈
00401834   call        @ILT+0(HowMany::HowMany) (00401005)	; 调用拷贝构造函数，把h的内容拷贝到Temp的内存中
00401839   mov         dword ptr [ebp-1Ch],eax
0040183C   lea         ecx,[h2]	
0040183F   push        ecx					; 将h2的内存地址[h2]压入堆栈
00401840   call        @ILT+640(f) (00401285)			; 调用f()函数
00401845   add         esp,8
00401848   mov         dword ptr [ebp-20h],eax
43:     }
0040184B   lea         ecx,[h2]
0040184E   call        @ILT+500(HowMany::~HowMany) (004011f9)	; 调用析构函数，销毁h2
00401853   mov         dword ptr [ebp-4],0FFFFFFFFh
0040185A   lea         ecx,[h]
0040185D   call        @ILT+500(HowMany::~HowMany) (004011f9)	; 调用析构函数，销毁h
44:     // getchar();
45:     return 0;
00401862   xor         eax,eax
46:   } ///:~

fun()函数的工作机制：

32:   HowMany f(HowMany x) {
33:     x.print("x argument inside f()");
004015DB   push        offset string "x argument inside f()" (0046f030)
004015E0   lea         ecx,[ebp+0Ch]
004015E3   call        @ILT+575(HowMany::print) (00401244)
34:     cout << "Return From f()" << endl;
004015E8   push        offset @ILT+200(std::endl) (004010cd)
004015ED   push        offset string "Return From f()" (0046f01c)
004015F2   push        offset std::cout (0047ce98)
004015F7   call        @ILT+660(std::operator<<) (00401299)
004015FC   add         esp,8
004015FF   mov         ecx,eax
00401601   call        @ILT+480(std::basic_ostream<char,std::char_traits<char> >::operator<<) (004011e5)
35:     return x;
00401606   lea         eax,[ebp+0Ch]				; [ebp+0C]为Temp的内存地址
00401609   push        eax
0040160A   mov         ecx,dword ptr [ebp+8]			; [ebp+8]为h2的内存地址，ecx指向h2内存块
0040160D   call        @ILT+0(HowMany::HowMany) (00401005)	; 调用拷贝构造函数，将Temp的内容拷贝到h2的内存中
00401612   mov         ecx,dword ptr [ebp-10h]
00401615   or          ecx,1
00401618   mov         dword ptr [ebp-10h],ecx
0040161B   mov         byte ptr [ebp-4],0
0040161F   lea         ecx,[ebp+0Ch]				; ecx保存Temp的内存地址
00401622   call        @ILT+500(HowMany::~HowMany) (004011f9)	; 调用析构函数，销毁Temp
00401627   mov         eax,dword ptr [ebp+8]			; eax保存h2的内存地址
36:   }

解析如下：

1. 对象h调用构造函数

2. 输出字符串“Entering f()”

3. 在进入f()函数之前，创建了一个临时对象Temp，调用拷贝构造函数，将对象h的内容拷贝到Temp中

4. 进入f()函数，在执行“return x”语句后，调用拷贝构造函数，将对象Temp的内容拷贝到h2中（完成了h2 = f(h)的工作）

5. 在f()函数结束前，为Temp调用析构函数，销毁Temp对象

6. 退出f()函数，在main函数结束前，先销毁对象h2，最后销毁对象h

----------------------------------------------------------------------------

逆向分析时执行“HowMany h2 = f(h);”语句过程中栈分布的记录：

*****

进入f()函数前（创建了一个临时对象Temp，调用拷贝构造函数，将对象h的内容拷贝到Temp中）

进入f()函数后

*********************************************************

再看<<Thinking in C++>>中的一段代码，更为清晰的讲解了拷贝构造函数的机制：

//: HowMany_2.cpp
#include <string>
#include <iostream>

using namespace std;

class HowMany {
  string name;
  static int objectCount;
  
public:
  HowMany(const string& id = "") {
    name = id;
    ++objectCount;
    print("HowMany()");
  }
  ~HowMany() {
    --objectCount;
    print("~HowMany()");
  }
  HowMany(const HowMany& h) {
    name = h.name + "copy";
    ++objectCount;
    print("HowMany(const HowMany&)");
  }
  
  void print(const string& msg = "") {
    if (msg.length() != 0) {
      cout << msg << endl;
    }
    cout << '\t' << name << ": "
		 << "objectCount = " << objectCount << endl;
    
    return ;
  }
};

int HowMany::objectCount = 0;

HowMany f(HowMany x) {
  x.print("x argument inside f()");
  cout << "Return From f()" << endl;
  return x;
}

int main() {
  {
    HowMany h("h");
    cout << "Entering f()" << endl;
    HowMany h2 = f(h);
    cout << "Call f(), no return value" << endl;
    f(h);
    cout << "After call to f()" << endl;
  }
  // getchar();
  return 0;
} ///:~

解释如下：

1. 创建对象h，并调用构造函数

2. 输出“Entering f()”字符串

3. 进入f()函数前，创建一个临时对象Temp，并调用拷贝构造函数，将对象h的内容拷贝到Temp中

4. 进入f()函数后，在“return x”时，调用拷贝构造函数，将对象Temp的内容拷贝到h2中，在函数结束前调用析构函数，销毁对象Temp

5. 输出字符串

6.进入f()函数前，创建一个临时对象Temp，并调用拷贝构造函数，将对象h的内容拷贝到Temp中

7. 进入f()函数后，创建一个临时对象x，在“return x”时，调用拷贝构造函数，将对象Temp的内容拷贝到x中，在函数结束前调用析构函数，先销毁对象Temp，再销毁对象x

8. 在main函数结束前，调用析构函数，先销毁对象h2，再销毁对象h