用汇编的眼光看C++（之类继承） ,（之虚函数） .

最新推荐文章于 2022-01-13 21:31:59 发布
最新推荐文章于 2022-01-13 21:31:59 发布
阅读量470 收藏
点赞数
分类专栏： 汇编 文章标签： 汇编 c++ manager class 设计模式 string

用汇编的眼光看C++（之类继承）

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】


 

    继承是类的一个基本属性，可是在类的继承过程中，函数是怎么初始化？怎么析构的呢？我们不妨看看下面这样的一段代码？

 

[cpp] view plain copy print ?
  1. class employee  
  2. {  
  3. public:  
  4.     employee() { printf("employee()!\n");}  
  5.     ~employee() { printf("~employee()!\n");}  
  6. };  
  7.   
  8. class manager : public employee  
  9. {  
  10. public:  
  11.     manager() { printf("manager()!\n");}  
  12.     ~manager() {  printf("~maneger()!\n");}  
  13. };  

class employee
{
public:
	employee() { printf("employee()!\n");}
	~employee() { printf("~employee()!\n");}
};

class manager : public employee
{
public:
	manager() { printf("manager()!\n");}
	~manager() {  printf("~maneger()!\n");}
};

    看到上面的代码，相信大家也明白了，我们定义了这样一个类。基类是empoyee，继承类是manager。我们看到manager是一种特殊的employee，那么在内存构建和析构的时候函数又是怎么安排的呢？

 

 

[cpp] view plain copy print ?
  1. 74:       manager m;  
  2. 00401268   lea         ecx,[ebp-4]  
  3. 0040126B   call        @ILT+60(manager::manager) (00401041)  
  4. 75:   }  
  5. 00401270   lea         ecx,[ebp-4]  
  6. 00401273   call        @ILT+0(manager::~manager) (00401005)  
  7. 00401278   pop         edi  
  8. 00401279   pop         esi  
  9. 0040127A   pop         ebx  
  10. 0040127B   add         esp,44h  
  11. 0040127E   cmp         ebp,esp  
  12. 00401280   call        __chkesp (00408760)  
  13. 00401285   mov         esp,ebp  
  14. 00401287   pop         ebp  

74:       manager m;
00401268   lea         ecx,[ebp-4]
0040126B   call        @ILT+60(manager::manager) (00401041)
75:   }
00401270   lea         ecx,[ebp-4]
00401273   call        @ILT+0(manager::~manager) (00401005)
00401278   pop         edi
00401279   pop         esi
0040127A   pop         ebx
0040127B   add         esp,44h
0040127E   cmp         ebp,esp
00401280   call        __chkesp (00408760)
00401285   mov         esp,ebp
00401287   pop         ebp

    我们发现manager的构造和析构其实也简单。构造函数其实就是在变量出现的时候进行构造。那什么时候析构呢？也就在函数快结束的时候进行析构。下面我们可以进一步讨论在manager的构造和析构究竟是怎么做的？

 

 

[cpp] view plain copy print ?
  1. 65:   class manager : public employee  
  2. 66:   {  
  3. 67:   public:  
  4. 68:       manager() { printf("manager()!\n");}  
  5. 004012A0   push        ebp  
  6. 004012A1   mov         ebp,esp  
  7. 004012A3   sub         esp,44h  
  8. 004012A6   push        ebx  
  9. 004012A7   push        esi  
  10. 004012A8   push        edi  
  11. 004012A9   push        ecx  
  12. 004012AA   lea         edi,[ebp-44h]  
  13. 004012AD   mov         ecx,11h  
  14. 004012B2   mov         eax,0CCCCCCCCh  
  15. 004012B7   rep stos    dword ptr [edi]  
  16. 004012B9   pop         ecx  
  17. 004012BA   mov         dword ptr [ebp-4],ecx  
  18. 004012BD   mov         ecx,dword ptr [ebp-4]  
  19. 004012C0   call        @ILT+40(employee::employee) (0040102d)  
  20. 004012C5   push        offset string "manager()!\n" (00431020)  
  21. 004012CA   call        printf (004086e0)  
  22. 004012CF   add         esp,4  
  23. 004012D2   mov         eax,dword ptr [ebp-4]  
  24. 004012D5   pop         edi  
  25. 004012D6   pop         esi  
  26. 004012D7   pop         ebx  
  27. 004012D8   add         esp,44h  
  28. 004012DB   cmp         ebp,esp  
  29. 004012DD   call        __chkesp (00408760)  
  30. 004012E2   mov         esp,ebp  
  31. 004012E4   pop         ebp  
  32. 004012E5   ret  

65:   class manager : public employee
66:   {
67:   public:
68:       manager() { printf("manager()!\n");}
004012A0   push        ebp
004012A1   mov         ebp,esp
004012A3   sub         esp,44h
004012A6   push        ebx
004012A7   push        esi
004012A8   push        edi
004012A9   push        ecx
004012AA   lea         edi,[ebp-44h]
004012AD   mov         ecx,11h
004012B2   mov         eax,0CCCCCCCCh
004012B7   rep stos    dword ptr [edi]
004012B9   pop         ecx
004012BA   mov         dword ptr [ebp-4],ecx
004012BD   mov         ecx,dword ptr [ebp-4]
004012C0   call        @ILT+40(employee::employee) (0040102d)
004012C5   push        offset string "manager()!\n" (00431020)
004012CA   call        printf (004086e0)
004012CF   add         esp,4
004012D2   mov         eax,dword ptr [ebp-4]
004012D5   pop         edi
004012D6   pop         esi
004012D7   pop         ebx
004012D8   add         esp,44h
004012DB   cmp         ebp,esp
004012DD   call        __chkesp (00408760)
004012E2   mov         esp,ebp
004012E4   pop         ebp
004012E5   ret

    我们发现，manager的构造里面添加了employee的缺省构造函数，那么析构函数呢？

 

 

[cpp] view plain copy print ?
  1. 69:       ~manager() {  printf("~maneger()!\n");}  
  2. 00401350   push        ebp  
  3. 00401351   mov         ebp,esp  
  4. 00401353   sub         esp,44h  
  5. 00401356   push        ebx  
  6. 00401357   push        esi  
  7. 00401358   push        edi  
  8. 00401359   push        ecx  
  9. 0040135A   lea         edi,[ebp-44h]  
  10. 0040135D   mov         ecx,11h  
  11. 00401362   mov         eax,0CCCCCCCCh  
  12. 00401367   rep stos    dword ptr [edi]  
  13. 00401369   pop         ecx  
  14. 0040136A   mov         dword ptr [ebp-4],ecx  
  15. 0040136D   push        offset string "~maneger()!\n" (00431040)  
  16. 00401372   call        printf (004086e0)  
  17. 00401377   add         esp,4  
  18. 0040137A   mov         ecx,dword ptr [ebp-4]  
  19. 0040137D   call        @ILT+5(employee::~employee) (0040100a)  
  20. 00401382   pop         edi  
  21. 00401383   pop         esi  
  22. 00401384   pop         ebx  
  23. 00401385   add         esp,44h  
  24. 00401388   cmp         ebp,esp  
  25. 0040138A   call        __chkesp (00408760)  
  26. 0040138F   mov         esp,ebp  
  27. 00401391   pop         ebp  
  28. 00401392   ret  

69:       ~manager() {  printf("~maneger()!\n");}
00401350   push        ebp
00401351   mov         ebp,esp
00401353   sub         esp,44h
00401356   push        ebx
00401357   push        esi
00401358   push        edi
00401359   push        ecx
0040135A   lea         edi,[ebp-44h]
0040135D   mov         ecx,11h
00401362   mov         eax,0CCCCCCCCh
00401367   rep stos    dword ptr [edi]
00401369   pop         ecx
0040136A   mov         dword ptr [ebp-4],ecx
0040136D   push        offset string "~maneger()!\n" (00431040)
00401372   call        printf (004086e0)
00401377   add         esp,4
0040137A   mov         ecx,dword ptr [ebp-4]
0040137D   call        @ILT+5(employee::~employee) (0040100a)
00401382   pop         edi
00401383   pop         esi
00401384   pop         ebx
00401385   add         esp,44h
00401388   cmp         ebp,esp
0040138A   call        __chkesp (00408760)
0040138F   mov         esp,ebp
00401391   pop         ebp
00401392   ret

    我们发现，manager构造的时候employee率先构造，然后打印manager；析构的时候，恰恰相反，manager首先析构自己，然后在再调用employee的析构函数，上面的汇编代码证明了一切。

 

用汇编的眼光看C++（之虚函数）

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】  


    虚函数是面向对象设计中的一个重要内容。它的出现使得我们只需要相同的接口函数，并可以得到不同的生成结果。但是有些朋友却知其然，不知其所以然，为什么会出现这样的结果，我们可以用一段代码说明问题。首先，我们先定义两个基本类型，一个是employee，一个是manager，看过前面一片博客的朋友应该都有点印象：

[cpp] view plain copy print ?
  1. class employee  
  2. {  
  3. public:  
  4.     employee() { }  
  5.     ~employee() {}  
  6.     virtual void print() const { printf("employee!\n");}  
  7. };  
  8.   
  9. class manager : public employee  
  10. {  
  11. public:  
  12.     manager() {}  
  13.     ~manager() {}  
  14.     void print() const {printf("manager!\n");}  
  15. };  
class employee
{
public:
	employee() { }
	~employee() {}
	virtual void print() const { printf("employee!\n");}
};

class manager : public employee
{
public:
	manager() {}
	~manager() {}
	void print() const {printf("manager!\n");}
};

    我们看到，和前面出现的成员函数稍微有一些不同，这里的print函数之前出现了virtual。然而正是这个virtual发挥了巨大的作用。可以毫不夸张地说，没有虚函数，基本上就没有设计模式，也就无法体现C++语言在面向对象设计中的巨大优越性。下面我们看看这个virtual是怎样发挥作用的？

[cpp] view plain copy print ?
  1. 76:       employee p;  
  2. 0040128D   lea         ecx,[ebp-10h]  
  3. 00401290   call        @ILT+45(employee::employee) (00401032)  
  4. 00401295   mov         dword ptr [ebp-4],0  
  5. 77:       manager m;  
  6. 0040129C   lea         ecx,[ebp-14h]  
  7. 0040129F   call        @ILT+65(manager::manager) (00401046)  
  8. 004012A4   mov         byte ptr [ebp-4],1  
  9. 78:       employee* e = &p;  
  10. 004012A8   lea         eax,[ebp-10h]  
  11. 004012AB   mov         dword ptr [ebp-18h],eax  
  12. 79:       e->print();  
  13. 004012AE   mov         ecx,dword ptr [ebp-18h]  
  14. 004012B1   mov         edx,dword ptr [ecx]  
  15. 004012B3   mov         esi,esp  
  16. 004012B5   mov         ecx,dword ptr [ebp-18h]  
  17. 004012B8   call        dword ptr [edx]  
  18. 004012BA   cmp         esi,esp  
  19. 004012BC   call        __chkesp (00408870)  
  20. 80:       e = &m;  
  21. 004012C1   lea         eax,[ebp-14h]  
  22. 004012C4   mov         dword ptr [ebp-18h],eax  
  23. 81:       e->print();  
  24. 004012C7   mov         ecx,dword ptr [ebp-18h]  
  25. 004012CA   mov         edx,dword ptr [ecx]  
  26. 004012CC   mov         esi,esp  
  27. 004012CE   mov         ecx,dword ptr [ebp-18h]  
  28. 004012D1   call        dword ptr [edx]  
  29. 004012D3   cmp         esi,esp  
  30. 004012D5   call        __chkesp (00408870)  
  31. 82:   }  
76:       employee p;
0040128D   lea         ecx,[ebp-10h]
00401290   call        @ILT+45(employee::employee) (00401032)
00401295   mov         dword ptr [ebp-4],0
77:       manager m;
0040129C   lea         ecx,[ebp-14h]
0040129F   call        @ILT+65(manager::manager) (00401046)
004012A4   mov         byte ptr [ebp-4],1
78:       employee* e = &p;
004012A8   lea         eax,[ebp-10h]
004012AB   mov         dword ptr [ebp-18h],eax
79:       e->print();
004012AE   mov         ecx,dword ptr [ebp-18h]
004012B1   mov         edx,dword ptr [ecx]
004012B3   mov         esi,esp
004012B5   mov         ecx,dword ptr [ebp-18h]
004012B8   call        dword ptr [edx]
004012BA   cmp         esi,esp
004012BC   call        __chkesp (00408870)
80:       e = &m;
004012C1   lea         eax,[ebp-14h]
004012C4   mov         dword ptr [ebp-18h],eax
81:       e->print();
004012C7   mov         ecx,dword ptr [ebp-18h]
004012CA   mov         edx,dword ptr [ecx]
004012CC   mov         esi,esp
004012CE   mov         ecx,dword ptr [ebp-18h]
004012D1   call        dword ptr [edx]
004012D3   cmp         esi,esp
004012D5   call        __chkesp (00408870)
82:   }

    上面是一段函数调用的代码，代码可以稍微有点长。不过没有关系，我们可以按照代码的行数一行一行地去进行说明和理解。

    76行： 我们创建了employee类型的一个变量p，这个可以从后面的employee的构造函数可以看出来

    77行： 我们创建了manager类型的一个变量，这个也可以从后面的manager的构造函数看出

    78行： 我们创建一个指针临时变量e，它保存了变量p的地址，这一句也比较简单

    79行： 我们发现79句下面共有7句汇编，其中第三句、第六句、第七句是平衡堆栈的时候用的，和我们的调用没有关系。那么call的edx是什么东西呢？原来函数调用的顺序是这样的：edx -> [ecx]  ->[ebp-0x18]，不知道大家看明白了没有。在内存的第一个字节记录一个指向print函数指针的指针，也就是edx。通过这个edx，我们就可以查找到位于edx地址的内容是什么。后来我们提取出来后发现[edx]的内容正是我们要查找的print函数地址。这里相当于一个二次寻址的过程。

    80行： 我们重新对临时变量e进行了赋值，此时e保存的是变量m的地址

    81行： 我们发现此时的寻找过程和79行惊奇地一致，原因就在于edx的内容不同罢了。也就是指向函数指针的指针发生了变化而已。


    试想一下，如果没有这个virtual函数，以上这段代码会发生什么差别呢？

[cpp] view plain copy print ?
  1. 76:       employee p;  
  2. 0040127D   lea         ecx,[ebp-10h]  
  3. 00401280   call        @ILT+45(employee::employee) (00401032)  
  4. 00401285   mov         dword ptr [ebp-4],0  
  5. 77:       manager m;  
  6. 0040128C   lea         ecx,[ebp-14h]  
  7. 0040128F   call        @ILT+65(manager::manager) (00401046)  
  8. 00401294   mov         byte ptr [ebp-4],1  
  9. 78:       employee* e = &p;  
  10. 00401298   lea         eax,[ebp-10h]  
  11. 0040129B   mov         dword ptr [ebp-18h],eax  
  12. 79:       e->print();  
  13. 0040129E   mov         ecx,dword ptr [ebp-18h]  
  14. 004012A1   call        @ILT+5(employee::print) (0040100a)  
  15. 80:       e = &m;  
  16. 004012A6   lea         ecx,[ebp-14h]  
  17. 004012A9   mov         dword ptr [ebp-18h],ecx  
  18. 81:       e->print();  
  19. 004012AC   mov         ecx,dword ptr [ebp-18h]  
  20. 004012AF   call        @ILT+5(employee::print) (0040100a)  
  21. 82:   }  
76:       employee p;
0040127D   lea         ecx,[ebp-10h]
00401280   call        @ILT+45(employee::employee) (00401032)
00401285   mov         dword ptr [ebp-4],0
77:       manager m;
0040128C   lea         ecx,[ebp-14h]
0040128F   call        @ILT+65(manager::manager) (00401046)
00401294   mov         byte ptr [ebp-4],1
78:       employee* e = &p;
00401298   lea         eax,[ebp-10h]
0040129B   mov         dword ptr [ebp-18h],eax
79:       e->print();
0040129E   mov         ecx,dword ptr [ebp-18h]
004012A1   call        @ILT+5(employee::print) (0040100a)
80:       e = &m;
004012A6   lea         ecx,[ebp-14h]
004012A9   mov         dword ptr [ebp-18h],ecx
81:       e->print();
004012AC   mov         ecx,dword ptr [ebp-18h]
004012AF   call        @ILT+5(employee::print) (0040100a)
82:   }

    很遗憾，这里就没有了动态查找的过程，所有的打印函数最终都指向了函数employee::print，此时多态性也不复存在了。


【预告： 下一片博客将介绍类中的静态变量和静态函数】

 

happylife1527
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从汇编看c++的虚拟继承以及其内存布局
12-22
先看第一种简单的情形，所有类中没有任何虚函数的菱形继承。 　　下面是c++源码： class Top {//虚基类 public:     int i;     Top(int ii) {         i = ii;     } }; class Left : public virtual Top { public:     int j;     Left(int jj， int ii) : Top(ii) {         j = jj;     } }; class Right : public virtual Top { public:
用汇编的眼光看C++（之类继承）
javasee
09-14 79
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 继承是类的一个基本属性，可是在类的继承过程中，函数是怎么初始化？怎么析构的呢？我们不妨看看下面这样的一段代码？ class employee { public: employee() { printf("employee()!\n");} ~employee() { print...
编译器是如何用汇编语言实现C++的虚函数表和隐式传递this指针(三)
尘世一小猿的专栏
06-06 874
//直接来个复杂的多重继承 #include class Base{ public: Base(){ puts("Base()"); } virtual void fun1() { puts("Base::fun1()"); } virtual void fun2() { puts("B
从汇编角度看继承和虚函数
weixin_30709061的博客
12-08 61
#include "stdafx.h"#include <stdio.h> class Base{public: virtual int basevt(){ return 1;}}; class Inherit:public Base{ public: int basevt(){ return 2;};}; int main(int arg...
用汇编的眼光看C/C++之深入指针
07-16
### 用汇编的眼光看C/C++之深入指针 #### 概述 在C/C++编程语言中，指针是一种极为重要的数据类型，能够直接操纵内存，从而提高程序的性能与灵活性。本文将深入探讨指针的概念及其在C/C++中的应用，并结合汇编语言...
如何获取C++类成员虚函数地址的示例代码
08-29
总结，获取C++虚函数地址的方法包括直接通过成员函数指针、使用内联汇编以及访问虚函数表。理解这些机制对于深入理解C++的虚函数机制和运行时类型信息的使用非常重要。不过，需要注意的是，这些操作通常属于底层编程...
从汇编看c++中默认构造函数的使用分析
09-05
在C++编程语言中，当一个类没有显式定义构造函数时，编译器会自动为这个类生成一个默认构造函数。默认构造函数的主要任务是初始化类的成员变量。然而，从汇编层面来看，这个过程并非总是涉及实际的函数调用。下面...
从汇编层面深度剖析C++虚函数
12-22
csdn网友所发的一篇博文《VC虚函数布局引发的问题》 从汇编角度分析了对象虚函数表的构，以及C++指针或者引用是如何利用这个表来实现运行时多态。 　诚然，C++虚函数的结构会因编译器不同而异，但所使用的原理是...
【C】深入浅出之函数栈帧
code farmer from sust
05-02 2224
函数栈帧、反汇编
C++中继承与派生是如何实现的？
lidiya007的博客
10-10 2797
面向对象编程的主要目的之一就是提供可重用的代码，强调可重用性。当我们在面临一个大的工程的时候，一般都会重用以前的代码，首先我们使用现有的代码可以节省编码时间，我们称重复的编码为重复的造轮子，重复的代码已经经过了测试，有利于我们避免向程序中引入错误，让我们的时间不必拘泥于这些细节。 使用C语言进行编程时，可以使用C标准的各种函数。C++提供更高层次的重用，如类库。 通过继承可以完成以下工作：
C++ 类的继承机制梳理
Mr___Song的博客
08-19 1478
类的继承 什么是继承？ 继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生新的类，称 派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程 为什么要有继承？ 纠其根本，最主要的目的就是要提高代码的复用率，更加容易切合大型的项目工程，但是为了提高复用率让编译器过多的参与到代码之中，代码的理...
C++实验二：类的继承机制的实现——电梯2.0
加载中.......
01-13 1864
实现对第一次实验结果Elevator类的功能扩展。在Elevator类已有功能的基础上派生AdvancedElevator类。AdvancedElevator类可以实现当多人在不同楼层等待乘坐上行或下行的同一部电梯时，能够合理的根据乘坐人的需求对电梯经停的楼层进行排序。
基础：C++的继承机制
david2000999的博客
05-12 247
C++的继承机制4.6.1 继承的基本语法4.6.2 继承方式4.6.3 继承中的对象模型4.6.4 继承中构造和析构顺序4.6.5 继承同名成员处理方式4.6.6 继承同名静态成员处理方式4.6.7 多继承语法（不推荐使用）4.6.8 菱形继承 继承是面向对象三大特性之一 我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。 这个时候我们就可以考虑利用继承的技术，减少重复代码 4.6.1 继承的基本语法 例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心
从底层汇编理解 c++ 引用实现机制
www 关注互联网最新技术
09-01 1万+
引用类型到底是什么？它和指针有什么关系？它本身占用内存空间吗？ 带着这些疑问，我们来进行分析。 先看代码： #include #include using namespace std; void main() { int x = 1; i
汇编语言中PTR的含义及作用
热门推荐
farmwang的专栏
12-06 1万+
汇编语言中PTR的含义及作用 mov ax,bx ;是把BX寄存器“里”的值赋予AX，由于二者都是word型，所以没有必要加“WORD”    mov ax,word ptr [bx];是把内存地址等于“BX寄存器的值”的地方所存放的数据，赋予ax。由于只是给出一个内存地址，不知道希望赋予ax的，是byte还是word，所以需要用word明确指出！ 所以，当两个操作数的宽度不一样时，
C++ 底层分析 2.构造-析构，继承
Mikasys的博客
04-27 262
析构函数（初始） 可以没有，有了必须按照规则用 作用：初始化对象用的，创造对象的时候调用 特点：3个 重载：函数名字一样 参数个数或者类型不一样 析构函数（清理）
从底层汇编理解 c++ 引用实现机制 （转+增加）
weixin_34151004的博客
02-05 104
参考：http://blog.csdn.net/wanwenweifly4/article/details/6739687 红色是我添加的，其他地方是原作者的。 主要是看了上面的这篇“从底层汇编理解 c++ 引用实现机制“的文章之后，觉得不错。就转了过来，同时，对文中的程序都在自己的机器上验证了一下。 使用的G++版本：g++ (GCC) 4.5.1 20100924 ...
深入理解函数调用与虚函数在C++中的多态实现
本文将深入探讨函数执行的原理，特别是涉及C++中的虚函数和动态联编。首先，我们将从汇编语言的角度理解函数调用的基本操作，因为这能揭示程序执行的底层机制。在可执行程序中，函数调用通过`call`指令实现，该指令...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值