VC驿站

 找回密码
 加入驿站

QQ登录

只需一步,快速开始

搜索
查看: 2698|回复: 4

[原创] C++类的构造函数与析构函数

[复制链接]
001
61_avatar_middle
在线会员 发表于 2016-7-5 22:09:49 | 显示全部楼层 |阅读模式
C++中每个类都有其构造与析构函数,它们负责对象的创建和对象的清理和回收,即使我们不写这两个,编译器也会默认为我们提供这些构造函数。下面仍然是通过反汇编的方式来说明C++中构造和析构函数是如何工作的。
一、编译器是否真的会默认提供构造与析构函数
在一般讲解C++的书籍中都会提及到当我们不为类提供任何构造与析构函数时编译器会默认提供这样六种成员函数:不带参构造,拷贝构造,“=”的重载函数,析构函数,以及带const和不带const的取地址符重载。但是编译器具体是怎么做的,下面来对其中的部分进行说明。
1.1.不带参构造
下面是一个例子:
  1. class test
  2. {
  3. private:
  4.     char szBuf[255];
  5. public:
  6.     static void print()
  7.     {
  8.         cout<<"hello world";
  9.     }   
  10. };
  11. void printhello(test t)
  12. {
  13.     t.print();
  14. }
  15. int main(int argc, char* argv[])
  16. {
  17.     test t;
  18.     printhello(t);
  19.     return 0;
  20. }
复制代码

下面是对应的汇编源码:
  1. 00401400   push        ebp
  2. 00401401   mov         ebp,esp
  3. 00401403   sub         esp,140h;栈顶向上抬了140h的空间用于存储类对象的数据
  4. 00401409   push        ebx
  5. 0040140A   push        esi
  6. 0040140B   push        edi
  7. 0040140C   lea         edi,[ebp-140h]
  8. 00401412   mov         ecx,50h
  9. 00401417   mov         eax,0CCCCCCCCh
  10. 0040141C   rep stos    dword ptr [edi]
  11. 26:       test t;
  12. 27:       printhello(t);
  13. 0040141E   sub         esp,100h
复制代码

从上面可以看到,在定义类的对象时并没有进行任何的函数调用,在进行对象的内存空间分配时仅仅是将栈容量扩大,就好像定义一个普通变量一样,也就是说在默认情况下编译器并不会提供不带参的构造函数,在初始化对象时仅仅将其作为一个普通变量,在编译之前计算出它所占内存的大小,然后分配,并不调用函数。
再看下面一个例子:
  1. class test
  2. {
  3. private:
  4.     char szBuf[255];
  5. public:
  6.     virtual void sayhello()
  7.     {
  8.         cout<<"hello world";
  9.     }
  10.     static void print()
  11.     {
  12.         cout<<"hello world";
  13.     }   
  14. };
  15. void printhello(test t)
  16. {
  17.     t.print();
  18. }
  19. int main(int argc, char* argv[])
  20. {
  21.     test t;
  22.     printhello(t);
  23.     return 0;
  24. }
复制代码
  1. 30:       test t;
  2. 0040143E   lea         ecx,[ebp-104h]
  3. 00401444   call        @ILT+140(test::test) (00401091)

  4. ;构造函数
  5. 004014A0   push        ebp
  6. 004014A1   mov         ebp,esp
  7. 004014A3   sub         esp,44h
  8. 004014A6   push        ebx
  9. 004014A7   push        esi
  10. 004014A8   push        edi
  11. 004014A9   push        ecx
  12. 004014AA   lea         edi,[ebp-44h]
  13. 004014AD   mov         ecx,11h
  14. 004014B2   mov         eax,0CCCCCCCCh
  15. 004014B7   rep stos    dword ptr [edi]
  16. 004014B9   pop         ecx
  17. 004014BA   mov         dword ptr [ebp-4],ecx
  18. 004014BD   mov         eax,dword ptr [ebp-4]
  19. 004014C0   mov         dword ptr [eax],offset test::`vftable' (0042f02c)
  20. 004014C6   mov         eax,dword ptr [ebp-4]
  21. 004014C9   pop         edi
  22. 004014CA   pop         esi
  23. 004014CB   pop         ebx
  24. 004014CC   mov         esp,ebp
  25. 004014CE   pop         ebp
复制代码

这段C++代码与之前的仅仅是多了一个虚函数,这个时候编译器为这个类定义了一个默认的构造函数,从汇编代码中可以看到,这个构造函数主要初始化了类对象的头4个字节,将虚函数表的地址放入到这个4个字节中,因此我们得出结论,一般编译器不会提供不带参的构造函数,除非类中有虚函数。
下面请看这样一个例子:
  1. class Parent
  2. {
  3. public:
  4.     Parent()
  5.     {
  6.         cout<<"parent!"<<endl;
  7.     }
  8. };

  9. class child: public Parent
  10. {
  11. private:
  12.     char szBuf[10];
  13. };

  14. int main()
  15. {
  16.     child c;
  17.     return 0;
  18. }
复制代码

下面是它的汇编代码:
  1. 27:       child c;
  2. 004013A8   lea         ecx,[ebp-0Ch]
  3. 004013AB   call        @ILT+100(child::child) (00401069)
  4. ;构造函数
  5. ;函数初始化代码略
  6. 004013E9   pop         ecx
  7. 004013EA   mov         dword ptr [ebp-4],ecx
  8. 004013ED   mov         ecx,dword ptr [ebp-4]
  9. 004013F0   call        @ILT+80(Parent::Parent) (00401055)
  10. ;最后函数的收尾工作,代码略
复制代码

从上面的代码看,当父类存在构造函数时,编译器会默认为子类添加构造函数,子类的构造函数主要是调用父类的构造函数。
  1. class Parent
  2. {
  3. public:
  4.     virtual sayhello()
  5.     {
  6.         cout<<"hello"<<endl;
  7.     }
  8. };

  9. class child: public Parent
  10. {
  11. private:
  12.     char szBuf[10];
  13. };

  14. int main()
  15. {
  16.     child c;
  17.     return 0;
  18. }
复制代码
  1. 27:       child c;
  2. 004013B8   lea         ecx,[ebp-10h]
  3. 004013BB   call        @ILT+100(child::child) (00401069)
  4. ;构造函数
  5. 004013FA   mov         dword ptr [ebp-4],ecx
  6. 004013FD   mov         ecx,dword ptr [ebp-4]
  7. 00401400   call        @ILT+80(Parent::Parent) (00401055);调用父类的构造函数
  8. 00401405   mov         eax,dword ptr [ebp-4]
  9. 00401408   mov         dword ptr [eax],offset child::`vftable' (0042f01c);初始化虚函数表
  10. 0040140E   mov         eax,dword ptr [ebp-4]
复制代码

从上面的代码中可以看到,当父类有虚函数时,编译器也会提供构造函数,主要用于初始化头四个字节的虚函数表的指针。
1.2.拷贝构造
当我们不写拷贝构造的时候,仍然能用一个对象初始化另一个对象,下面是这样的一段代码
  1. int main(int argc, char* argv[])
  2. {
  3.     test t1;
  4.     test t(t1);
  5.     printhello(t);
  6.     return 0;
  7. }
复制代码

我们还是用之前定义的那个test类,将类中的虚函数去掉,下面是对应的反汇编代码
  1. 30:       test t1;
  2. 31:       test t(t1);
  3. 0040141E   mov         ecx,3Fh
  4. 00401423   lea         esi,[ebp-100h]
  5. 00401429   lea         edi,[ebp-200h]
  6. 0040142F   rep movs    dword ptr [edi],dword ptr [esi]
  7. 00401431   movs        word ptr [edi],word ptr [esi]
  8. 00401433   movs        byte ptr [edi],byte ptr [esi]
复制代码

从这段代码中可以看到,利用一个已有的类对象来初始化一个新的对象时,编译器仍然没有为其提供所谓的默认拷贝构造函数,在初始化时利用串操作,将一个对象的内容拷贝到另一个对象。
当类中有虚函数时,会提供一个拷贝构造,主要用于初始化头四个字节的虚函数表,在进行对象初始化时仍然采用的是直接内存拷贝的方式。
由于默认的拷贝构造是进行简单的内存拷贝,所以当类中的成员中有指针变量时尽量自己定义拷贝构造,进行深拷贝,否则在以后进行析构时会崩溃。
另外几种就不再一一进行说明,它们的情况与上面的相似,有兴趣的可以自己编写代码验证。另外需要注意的是,只要定义了任何一个类型的构造函数,那么编译器就不会提供默认的构造函数。
最后总结一下默认情况下编译器不提供这些函数,只有父类自身有构造函数,或者自身或父类有虚函数时,编译器才会提供默认的构造函数。
二、何时会调用构造函数
当对一个类进行实例化,也就是创建一个类的对象时,会调用其构造函数。
对于栈中的局部对象,当定义一个对象时会调用构造函数
对于堆对象,当用户调用new新建对象时调用构造函数
对于全局对象和静态对象,当程序运行之处会调用构造函数
下面重点说明当对象作为函数参数和返回值时的情况
2.1.作为函数参数
当对象作为函数参数时调用的是拷贝构造,而不是普通的构造函数
下面是一个例子代码:
  1. class CA
  2. {
  3. public:
  4.     CA()
  5.     {
  6.         cout<<"构造函数"<<endl;
  7.     }

  8.     CA(CA &ca)
  9.     {
  10.         cout<<"拷贝构造"<<endl;
  11.     }
  12. private:
  13.     char szBuf[255];
  14. };

  15. void Test(CA a)
  16. {
  17.     return;
  18. }
  19. int main()
  20. {
  21.     CA a;
  22.     Test(a);
  23.     return 0;
  24. }
复制代码

对应的汇编代码如下:
  1. 33:       Test(a);
  2. 004013F9   sub         esp,100h
  3. 004013FF   mov         ecx,esp
  4. 00401401   lea         eax,[ebp-100h];eax保存对象的首地址
  5. 00401407   push        eax
  6. 00401408   call        @ILT+15(CA::CA) (00401014)
  7. 0040140D   call        @ILT+35(Test) (00401028)
  8. ;拷贝构造代码
  9. cout<<"拷贝构造"<<endl;
  10. 0040152D   push        offset @ILT+50(std::endl) (00401037)
  11. 00401532   push        offset string "\xbf\xbd\xb1\xb4\xb9\xb9\xd4\xec" (0042f028)
  12. 00401537   push        offset std::cout (00434088)
  13. 0040153C   call        @ILT+170(std::operator<<) (004010af)
  14. 00401541   add         esp,8
  15. 00401544   mov         ecx,eax
  16. 00401546   call        @ILT+125(std::basic_ostream<char,std::char_traits<char> >::operator<<) (00401082)
  17. 21:       }
  18. 0040154B   mov         eax,dword ptr [ebp-4]
  19. 0040154E   pop         edi
  20. 0040154F   pop         esi
  21. 00401550   pop         ebx
  22. 00401551   add         esp,44h
  23. 00401554   cmp         ebp,esp
  24. 00401556   call        __chkesp (004025d0)
  25. 0040155B   mov         esp,ebp
  26. 0040155D   pop         ebp
  27. 0040155E   ret         4
复制代码

从上面的代码来看,当对象作为函数参数时,首先调用构造函数,将参数进行拷贝。
2.2.作为函数的返回值
  1. class CA
  2. {
  3. public:
  4.     CA()
  5.     {
  6.         cout<<"构造函数"<<endl;
  7.     }

  8.     CA(CA &ca)
  9.     {
  10.         cout<<"拷贝构造"<<endl;
  11.     }
  12. private:
  13.     char szBuf[255];
  14. };

  15. CA Test()
  16. {
  17.     CA a;
  18.     return a;
  19. }

  20. int main()
  21. {
  22.     CA a = Test();
  23.     return 0;
  24. }
复制代码
  1. 34:       CA a = Test();
  2. 0040155E   lea         eax,[ebp-200h];eax保存的是对象a 的首地址
  3. 00401564   push        eax
  4. 00401565   call        @ILT+145(Test) (00401096);调用test函数
  5. 0040156A   add         esp,4
  6. 0040156D   push        eax;函数返回的临时存储区的地址
  7. 0040156E   lea         ecx,[ebp-100h]
  8. 00401574   call        @ILT+15(CA::CA) (00401014);调用拷贝构造

  9. ;test函数
  10. 28:       CA a;
  11. 004013BE   lea         ecx,[ebp-100h]
  12. 004013C4   call        @ILT+10(CA::CA) (0040100f)
  13. 29:       return a;
  14. 004013C9   lea         eax,[ebp-100h]
  15. 004013CF   push        eax
  16. 004013D0   mov         ecx,dword ptr [ebp+8]
  17. 004013D3   call        @ILT+15(CA::CA) (00401014);调用拷贝构造
  18. 004013D8   mov         eax,dword ptr [ebp+8];ebp + 8是用来存储对象的临时存储区
复制代码

通过上面的反汇编代码可以看到,在函数返回时会首先调用拷贝构造,将对象的内容拷贝到一个临时存储区中,然后通过eax寄存器返回,在需要利用函数返回值时再次调用拷贝构造,将eax中的内容拷贝到对象中。
另外从这些反汇编代码中可以看到,拷贝构造以对象的首地址为参数,返回新建立的对象的地址。
当需要对对象的内存进行拷贝时调用拷贝构造,拷贝构造只能传递对象的地址或者引用,不能传递对象本身,我们知道对象作为函数参数时会调用拷贝构造,如果以对象作为拷贝构造的参数,那么回造成拷贝构造的无限递归。
三、何时调用析构函数
对于析构函数的调用我们仍然分为以下几个部分:
局部类对象:当对象所在的生命周期结束后,即一般语句块结束或者函数结束时会调用
全局对象和静态类对象:当程序结束时会调用构造函数
堆对象:当程序员显式调用delete释放空间时调用
3.1.参数对象
下面是一个例子代码:
  1. class CA
  2. {
  3. public:
  4.     ~CA()
  5.     {
  6.         printf("~CA()\n");
  7.     }
  8. private:
  9.     char szBuf[255];
  10. };

  11. void Test(CA a)
  12. {
  13.     printf("test()\n");
  14. }

  15. int main()
  16. {
  17.     CA a;
  18.     Test(a);
  19.     return 0;
  20. }
复制代码

下面是它的反汇编代码
  1. ;Test(a)
  2. 0040133A   sub         esp,100h;在main函数栈外开辟一段内存空间用于保存函数参数
  3. 00401340   mov         ecx,3Fh;类大小为255个字节,为了复制这块内存,每次复制4字节,共需要63次
  4. 00401345   lea         esi,[ebp-10Ch];esi保存的是对象的首地址
  5. 0040134B   mov         edi,esp;参数首地址
  6. 0040134D   rep movs    dword ptr [edi],dword ptr [esi];执行复制操作
  7. 0040134F   movs        word ptr [edi],word ptr [esi]
  8. 00401351   movs        byte ptr [edi],byte ptr [esi];将剩余几个字节也复制
  9. 00401352   call        @ILT+5(Test) (0040100a);调用test函数
  10. ;调用Test函数
  11. 23:       printf("test()\n");
  12. 00401278   push        offset string "test()\n" (0042f01c)
  13. 0040127D   call        printf (00401640)
  14. 00401282   add         esp,4
  15. 24:   }
  16. 00401285   lea         ecx,[ebp+8];参数首地址
  17. 00401288   call        @ILT+0(CA::~CA) (00401005)
复制代码

从上面的代码看,当类对象作为函数参数时,首先会调用拷贝构造(当程序不提供拷贝构造时,系统默认在对象之间进行简单的内存复制,这个就是提供的默认拷贝构造函数)然后当函数结束,程序执行到函数大括号初时,首先调用析构完成对象内存的释放,然后执行函数返回和做最后的清理工作
3.2.函数返回对象
下面是函数返回对象的代码:
  1. class CA
  2. {
  3. public:
  4.     ~CA()
  5.     {
  6.         printf("~CA()\n");
  7.     }
  8. private:
  9.     char szBuf[255];
  10. };

  11. CA Test()
  12. {
  13.     printf("test()\n");
  14.     CA a;
  15.     return a;
  16. }

  17. int main()
  18. {
  19.     CA a = Test();
  20.     return 0;
  21. }
复制代码

30:       CA a = Test();
0040138E   lea         eax,[ebp-100h];eax保存了对象的地址
00401394   push        eax
00401395   call        @ILT+20(Test) (00401019)
0040139A   add         esp,4
31:       return 0;
0040139D   mov         dword ptr [ebp-104h],0
004013A7   lea         ecx,[ebp-100h]
004013AD   call        @ILT+0(CA::~CA) (00401005);调用类的析构函数
004013B2   mov         eax,dword ptr [ebp-104h]
32:   }
;test函数
24:       CA a;
25:       return a;
004012AA   mov         ecx,3Fh
004012AF   lea         esi,[ebp-10Ch];esi保存的是类对象的首地址
004012B5   mov         edi,dword ptr [ebp+8];ebp+8是当初调用这个函数时传进来的类的首地址
004012B8   rep movs    dword ptr [edi],dword ptr [esi]
004012BA   movs        word ptr [edi],word ptr [esi]
004012BC   movs        byte ptr [edi],byte ptr [esi]
004012BD   mov         eax,dword ptr [ebp-110h]
004012C3   or          al,1
004012C5   mov         dword ptr [ebp-110h],eax
004012CB   lea         ecx,[ebp-10Ch]
004012D1   call        @ILT+0(CA::~CA) (00401005);调用析构函数
004012D6   mov         eax,dword ptr [ebp+8]
当类作为返回值返回时,如果定义了一个变量来接收这个返回值,那么在调用函数时会首先保存这个值,然后直接复制到这个内存中,但是接着执行类的析构函数析构在函数中定义的类对象,接受返回值得这块内存一直等到它所在的语句块结束才调用析构
如果不要这个返回值时又如何呢,下面的代码说明了这个问题
  1. int main()
  2. {
  3.     Test();
  4.     printf("main()\n");
  5.     return 0;
  6. }
复制代码
  1. 30:       Test();
  2. 0040138E   lea         eax,[ebp-100h]
  3. 00401394   push        eax
  4. 00401395   call        @ILT+20(Test) (00401019)
  5. 0040139A   add         esp,4
  6. 0040139D   lea         ecx,[ebp-100h]
  7. 004013A3   call        @ILT+0(CA::~CA) (00401005)
  8. 31:       printf("main()\n");
  9. 004013A8   push        offset string "main()\n" (0042f030)
  10. 004013AD   call        printf (00401660)
  11. 004013B2   add         esp,4
复制代码

同样可以看到当我们不需要这个返回值时,函数仍然会将对象拷贝到这块临时存储区中,但是会立即进行析构对这块内存进行回收。




上一篇:C++类详解
下一篇:C++多态的实现
51_avatar_middle
online_admins 发表于 2016-7-6 16:09:31 | 显示全部楼层
好文,支持!C++类的构造函数与析构函数
26_avatar_middle
在线会员 发表于 2016-7-13 22:22:32 来自手机 | 显示全部楼层
我就笑笑不说话1468448552.58
46_avatar_middle
在线会员 发表于 2017-5-2 08:39:52 | 显示全部楼层
每个类都有其构造与析构函数
08_avatar_middle
在线会员 发表于 2017-8-27 12:20:21 | 显示全部楼层
支持一下
您需要登录后才可以回帖 登录 | 加入驿站 qq_login

本版积分规则

关闭

站长提醒上一条 /2 下一条

QQ|小黑屋|手机版|VC驿站 ( 辽ICP备09019393号tongdun|网站地图wx_jqr

GMT+8, 2019-6-17 02:03

Powered by Discuz! X3.4

© 2009-2019 cctry.com

快速回复 返回顶部 返回列表