c++多继承条件下的虚函数列表及其内容

最新推荐文章于 2024-02-04 21:17:43 发布
最新推荐文章于 2024-02-04 21:17:43 发布
阅读量1k 收藏
点赞数
分类专栏： 编程 文章标签： c++ 语言 继承
首先还是简单定义三个类

[cpp]  view plain copy
  1. class A  
  2. {  
  3. private:  
  4.     int ma;  
  5.     int mb;  
  6. public:  
  7.     A()  
  8.     {  
  9.         ma = 1;  
  10.         mb = 2;  
  11.     }  
  12.       
  13.     virtual void Name()  
  14.     {  
  15.         cout<<"this is A"<<endl;      
  16.     }  
  17.   
  18.     virtual void special()  
  19.     {  
  20.         cout<<"Hello kitty"<<endl;  
  21.     }  
  22.   
  23.     virtual ~A()  
  24.     {  
  25.         cout<<"this is the virtual function of A"<<endl;  
  26.     }  
  27. };  
  28.   
  29.   
  30. class B  
  31. {  
  32. private:  
  33.     int mc;  
  34. public:  
  35.     B()  
  36.     {  
  37.         mc = 3;  
  38.     }  
  39.   
  40.       
  41.     virtual void Name()  
  42.     {  
  43.         cout<<"this is B"<<endl;      
  44.     }  
  45.   
  46.       
  47.     virtual void special()  
  48.     {  
  49.             cout<<"Hello Motor"<<endl;  
  50.     }  
  51.       
  52.   
  53.     virtual ~B()  
  54.     {  
  55.         cout<<"this is the virtual function of B"<<endl;  
  56.     }  
  57. };  
  58.   
  59. class C:public A,public B  
  60. {  
  61. public:  
  62.     C()  
  63.     {  
  64.   
  65.     }  
  66.     virtual void special()  
  67.     {  
  68.         cout<<"hello world"<<endl;  
  69.     }  
  70.   
  71.      
  72.     virtual ~C()  
  73.     {  
  74.         cout<<"this is the virtual function of C"<<endl;  
  75.     }  
  76.   
  77. };  

然后是测试函数

[cpp]  view plain copy
  1. int experimentClassUpDownPointer()  
  2. {  
  3.     C c;  
  4.     A *a;  
  5.     B *b;  
  6.   
  7.     a = &c;  
  8.     b = &c;  
  9.     a->Name();  
  10.     b->Name();  
  11.       
  12.     return 1;  
  13. }  

首先进入c的构造函数体内，看看它的反汇编代码是什么

去除了初始化和一些校验代码后

[cpp]  view plain copy
  1. 002E2075  push        eax    
  2. 002E2076  lea         eax,[ebp-0Ch]    
  3. 002E2079  mov         dword ptr fs:[00000000h],eax    
  4. 002E207F  mov         dword ptr [ebp-14h],ecx    
  5. 002E2082  mov         ecx,dword ptr [ebp-14h]    
  6. 002E2085  call        A::A (2E1208h)    
  7. 002E208A  mov         dword ptr [ebp-4],0    
  8. 002E2091  mov         ecx,dword ptr [ebp-14h]    
  9. 002E2094  add         ecx,0Ch    
  10. 002E2097  call        B::B (2E11F9h)    
  11. 002E209C  mov         eax,dword ptr [ebp-14h]    
  12. 002E209F  mov         dword ptr [eax],offset C::`vftable' (2EB944h)    
  13. 002E20A5  mov         eax,dword ptr [ebp-14h]    
  14. 002E20A8  mov         dword ptr [eax+0Ch],offset C::`vftable' (2EB930h)   

然后画出我理解的关系图



读过反汇编的应该很清楚要特别列出ebp的原因，因为对函数初始申请的ebp—esp之间的内存进行操作时候，经常以ebp作为基准。


在这段代码中，对象的起始地址储存在epb-14h处，可以注意到，当需要寄存器指向对象时，常用此处的值来进行赋值。


A的反汇编代码就不再看了，和单继承时候一样，要注意到的是进入A的构造函数后其中的this指针依然指向对象c的起始地址，这个是与后面B的构造函数内的this不同的；再一个便是用A的虚函数列表的地址给c的虚函数指针赋值，这个已经讨论过，不再重复。


然后看在B的构造函数内发生了什么。首先注意到在进入B的构造函数前

[cpp]  view plain copy
  1. 002E2091  mov         ecx,dword ptr [ebp-14h]    
  2. 002E2094  add         ecx,0Ch   

第一句是恢复ecx指向对象c，然后又向后移动12个字节，因为一个虚指针和两个整型变量共占有12个字节


完整代码如下

[cpp]  view plain copy
  1. class B  
  2. {  
  3. private:  
  4.     int mc;  
  5. public:  
  6.     B()  
  7. 002E2100  push        ebp    
  8. 002E2101  mov         ebp,esp    
  9. 002E2103  sub         esp,0CCh    
  10. 002E2109  push        ebx    
  11. 002E210A  push        esi    
  12. 002E210B  push        edi    
  13. 002E210C  push        ecx    
  14. 002E210D  lea         edi,[ebp-0CCh]    
  15. 002E2113  mov         ecx,33h    
  16. 002E2118  mov         eax,0CCCCCCCCh    
  17. 002E211D  rep stos    dword ptr es:[edi]    
  18.   
  19. 002E211F  pop         ecx    
  20. 002E2120  mov         dword ptr [ebp-8],ecx    
  21. 002E2123  mov         eax,dword ptr [this]    
  22. 002E2126  mov         dword ptr [eax],offset B::`vftable' (2EB958h)    
  23.     {  
  24.         mc = 3;  
  25. 002E212C  mov         eax,dword ptr [this]    
  26. 002E212F  mov         dword ptr [eax+4],3    
  27.     }  
  28. 002E2136  mov         eax,dword ptr [this]    
  29. 002E2139  pop         edi    
  30. 002E213A  pop         esi    
  31. 002E213B  pop         ebx    
  32. 002E213C  mov         esp,ebp    
  33. 002E213E  pop         ebp    
  34. 002E213F  ret    

002E211D之前是初始化，忽略。直接从下一行开始看，从内容上看与单继承基本一直，但是不要忘了此时this和ecx都指向的是对象c往后便宜十二个字节处。

那么也就是说在多继承的时候，子类会分别给父类开辟空间进行存储，如果父类都有虚指针，那么有多少个父类，基类中就会有多少个虚指针。同时从整体上看，他们又是连续存储的。存储完父类1的变量后，紧接着存储父类2。

理解以上后，其他的也就没什么了，要提一下的是，与父类A的构造函数类似，B同样将自己的虚函数列表的地址写入虚指针2。


回到c的构造函数，看看又会发生什么。

[cpp]  view plain copy
  1. 002E209C  mov         eax,dword ptr [ebp-14h]    
  2. 002E209F  mov         dword ptr [eax],offset C::`vftable' (2EB944h)    
  3. 002E20A5  mov         eax,dword ptr [ebp-14h]    
  4. 002E20A8  mov         dword ptr [eax+0Ch],offset C::`vftable' (2EB930h)   

在单继承的时候说过，c会用它的虚函数列表重写虚函数指针。同样都是父类，那么父类B也不会有特殊。

ebp-14h处的内存存储了对象的地址还记得吧，那么这就很清楚了，ecx和ecx+0ch分别指向两个虚函数指针，然后分别用不同的地址重新赋值。




谈完虚继承条件下关于虚函数和成员变量如何存储的问题，接下来看看所谓虚函数列表究竟是怎么回事。

[cpp]  view plain copy
  1. A *a;  
  2.     B *b;  
  3.   
  4.     a = &c;  
  5. 002E1F3C  lea         eax,[ebp-24h]    
  6. 002E1F3F  mov         dword ptr [ebp-30h],eax    

上面说明对象c的起始地址是ebp-24h，刚才说了c的起始地址别存储在ebp-14h处，都用到了ebp，不要晕。此时的ebp是测试函数内的ebp，ebp-14h处的ebp是C的构造函数体内的ebp，他们的值虽然可能是一样的。理解程序的时候最好根据函数看做不同的ebp.

然后完成a和b的赋值

[cpp]  view plain copy
  1. a = &c;  
  2. 002E1F3C  lea         eax,[ebp-24h]    
  3. 002E1F3F  mov         dword ptr [ebp-30h],eax    
  4.     
  5.   b = &c;  
  6. 002E1F42  lea         eax,[ebp-24h]    
  7. 002E1F45  test        eax,eax    
  8. 002E1F47  je          experimentClassUpDownPointer+67h (2E1F57h)    
  9. 002E1F49  lea         ecx,[ebp-24h]    
  10. 002E1F4C  add         ecx,0Ch    
  11. 002E1F4F  mov         dword ptr [ebp-110h],ecx    
  12. 002E1F55  jmp         experimentClassUpDownPointer+71h (2E1F61h)    
  13. 002E1F57  mov         dword ptr [ebp-110h],0    
  14. 002E1F61  mov         edx,dword ptr [ebp-110h]    
  15. 002E1F67  mov         dword ptr [ebp-3Ch],edx    

接着看看如何调用虚函数。


[cpp]  view plain copy
  1. a->Name();  
  2. 002E1F6A  mov         eax,dword ptr [ebp-30h]    
  3. 002E1F6D  mov         edx,dword ptr [eax]    
  4. 002E1F6F  mov         esi,esp    
  5. 002E1F71  mov         ecx,dword ptr [ebp-30h]    
  6. 002E1F74  mov         eax,dword ptr [edx]    
  7. 002E1F76  call        eax    
  8. 002E1F78  cmp         esi,esp    
  9. 002E1F7A  call        @ILT+805(__RTC_CheckEsp) (2E132Ah)    
  10. 重点在  
  11. 002E1F6A  mov         eax,dword ptr [ebp-30h]    
  12. 002E1F6D  mov         edx,dword ptr [eax]    
  13. 和  
  14. 002E1F74  mov         eax,dword ptr [edx]    
  15. 002E1F76  call        eax   

刚才讲起始地址放入ebp-30h处，这个时候先将对象起始地址写入eax，然后取出四个字节的内容放入edx，那么edx里面是什么？当然就是第一个虚函数指针的值，也就是第一个虚函数列表的地址。此时edx是

EDX = 002EB944

接着将edx指向的地址的四个字节写入eax，此时eax是什么？是第一个虚指针指向的虚函数列表的第一项，来看看究竟是什么。

[cpp]  view plain copy
  1. 0x002EB944  0d 12 2e 00 a9 11 2e 00 9f 11 2e 00 00 00 00 00 34 ce 2e 00 9d 13 2e 00 3b 11 2e 00 5a 10 2e    

第一项是

002e120d这也是即将调用的函数，接着进入ILT表。

看到

[cpp]  view plain copy
  1. A::Name:  
  2. 002E120D  jmp         A::Name (2E1CF0h)    

不急着进入函数体，我们看看虚函数表后面都指向什么，第二项是002e11a9

[cpp]  view plain copy
  1. C::special:  
  2. 002E11A9  jmp         C::special (2E2350h)   

第三项是002e119f

[cpp]  view plain copy
  1. C::`vector deleting destructor':  
  2. 002E119F  jmp         C::`scalar deleting destructor' (2E24D0h)   

是c的析构函数。


继续第二个调用

[cpp]  view plain copy
  1. b->Name();  
  2. 002E1F7F  mov         eax,dword ptr [ebp-3Ch]    
  3. 002E1F82  mov         edx,dword ptr [eax]    
  4. 002E1F84  mov         esi,esp    
  5. 002E1F86  mov         ecx,dword ptr [ebp-3Ch]    
  6. 002E1F89  mov         eax,dword ptr [edx]    
  7. 002E1F8B  call        eax    
  8. 002E1F8D  cmp         esi,esp    
  9. 002E1F8F  call        @ILT+805(__RTC_CheckEsp) (2E132Ah)  


[cpp]  view plain copy
  1. 002E1F7F  mov         eax,dword ptr [ebp-3Ch]  

这个是什么呢？回看b的初始代码有这么几行

[cpp]  view plain copy
  1. 002E1F49  lea         ecx,[ebp-24h]    
  2. 002E1F4C  add         ecx,0Ch    
  3. 002E1F4F  mov         dword ptr [ebp-110h],ecx    
  4. 002E1F55  jmp         experimentClassUpDownPointer+71h (2E1F61h)  

完成校验后跳入

[cpp]  view plain copy
  1. 002E1F61  mov         edx,dword ptr [ebp-110h]    
  2. 002E1F67  mov         dword ptr [ebp-3Ch],edx    

这时候就很清楚了,ebp-3ch处存储的就是对象起始地址往后偏移12个字节后的地址。那么是什么呢？就是第二个虚指针的地址。


重新回到b->Name()的调用

首先取出ebp-3ch处的值，也就是虚指针的地址，放入eax,然后将虚指针的值，也就是虚函数列表的首地址放入edx，此时eax和edx的值如下。

[cpp]  view plain copy
  1. EAX = 001BF868 EBX = 7FFA01A2 ECX = 1043ED48 EDX = 002EB930  
  2.   
  3. 0x002EB930  9d 13 2e 00 dc 10 2e 00 be 10 2e 00 00 00 00 00 58 cd 2e 00 0d 12 2e 00 a9 11 2e 00 9f 11 2e  

第一项是002e139d

进入ILT表

[cpp]  view plain copy
  1. B::Name:  
  2. 002E139D  jmp         B::Name (2E2150h)    

第二项是002e10dc

第三项是002e10be

这两项都不在ILT表中，那么为什么呢？

回过头看一下，C的对象应该包含多少个虚函数。

显然有A的name和b的name,还有C的special,z这个完成了对父类的覆盖，然后便是覆盖了父类的虚析构函数。这四个之前已经完全写入了两个虚函数列表，后面自然就没有了，但是指向什么呢，很简单做个实验即可。


已经知道了第二个虚函数列表的地址，这个实验就很简单了。代码

[cpp]  view plain copy
  1. typedef void (*funcF)();  
  2.     char *pt = (char *)&c;  
  3.     pt = pt+12;  
  4.     int **pointer;  
  5.     pointer = (int **)(pt);  
  6.     funcF funcT;  
  7.   
  8.     for(int i=0;i<3;i++)  
  9.     {  
  10.         funcT = (funcF)pointer[0][i];  
  11.         funcT();  
  12.     }  
结果：


虚表不存在对齐的问题。

单线多继承的时候，如C继承B，B继承A。那么C类的对象存在一个虚指针。



不负责任猜想“：

在运行过程中，每次进入一个基类的时候，ecx都会保存将要构建的基类对象的地址，其实是不是通过ecx来完成this指针的值得变化？

不过虽说是构造基类对象，只不过是为了说起来简单而已，可以看到编译过程中内存的地址只有一块，不存在分别申请空间，无论有多少个父类，都只有一块连续的存储空间。每次进入不同的父类的构造函数，变化的只有this指针而已。

再次拥抱
关注
专栏目录
C++基础知识 - 继承的虚函数表
骆驼胡杨的博客
02-24 220
继承的虚函数表 #include <iostream> #include <Windows.h> using namespace std; class Father { public: virtual void func1() { cout << "调用Father虚函数Func1()" << endl; } virtual void func2() { cout << "调用Father虚函数Func2()" << endl;
面试八股文：C++ 多态 继承 重载 虚函数
m0_38086244的博客
10-18 458
C++ 支持多态、继承和函数重载，这些是面向对象编程（OOP）的基本概念。方法，它会根据实际对象的类型来选择正确的函数实现。这是多态的一个示例，同时还涵盖了继承和虚函数。函数中，使用多态性来调用不同类型的对象的。是派生类，它们都重写了。
C++多继承下虚函数
11-14 183
 直接上代码#include using namespace std;class A{ public: virtual void funcA(){}};class B1:public virtual A{ public: virtual void funcB1(){}};class B2:public virtual A{ public:
C++多继承下的虚函数表(C++学习)
weixin_33971977的博客
11-17 174
在学习C++的多态实现时,曾经有这样的疑问: 假设派生类继承了多个基类,基类里都有虚函数, 也就是说派生类继承了多个虚表, 那派生类他自己的虚函数放在哪个虚表中呢? 在论坛里请教了各位大牛后,这个问题很快的解决了,我们通过代码来测试: class A { public: virtual void ...
C++ 虚函数表 多重继承
weixin_33800463的博客
04-23 186
上次研究的是单继承的情况，这次研究多重继承下的虚函数表的排列情况。这次A，A1,A2,B这几个类的继承关系如下图： 测试代码如下：#include<iostream> using namespace std; class A { public: virtual void...
C++多重继承的虚函数表
C++ER的博客
11-10 978
#include <iostream> using namespace std; class Father { public: virtual void func1() { cout << "Father::func1" << endl; } virtual void func2() { cout << "Father::func2" << endl; } virtual void func3() { cout << "Fat
C++ 虚继承对基类构造函数调用顺序的影响
01-20
继承作为面向对象编程的一种基本特征，其使用频率非常高。而继承包含了虚拟继承和普通继承，在可见性上分为public、protected、private。可见性继承比较简单，而虚拟继承对学习c++的难度较大。 　首先，虚拟继承与...
c++课件第十章虚函数和多态性共19页.pdf.zip
10-29
本课件的19页内容可能涵盖了虚函数和多态性的基本概念、语法、应用场景，以及如何在实际编程中利用这些特性进行设计和编码。学习这部分内容对于深入理解C++的面向对象特性至关重要，能够帮助开发者编写出更加灵活、...
C++ 类 sizeof 计算大小 虚函数 虚继承 虚基类 虚函数表
neninee的博客
09-15 2720
文章目录c++类的大小计算关于类/对象大小的计算一.简单情况的计算二.空类的大小三.含有虚函数成员（1）在派生类中不对基类的虚函数进行覆盖，同时派生类中还拥有自己的虚函数在派生类中对基类的虚函数进行覆盖（3）多继承：无虚函数覆盖（4）多重继承，含虚函数覆盖四.虚继承的情况 c++类的大小计算 c++中类所占的大小计算并没有想象中那么简单，因为涉及到虚函数成员，静态成员，虚继承，多继承以及空类等，不同情况有对应的计算方式，在此对各种情况进行总结。 首先要明确一个概念，平时所声明的类只是一种类型定义，它本身是没
C++多继承及虚函数
weixin_41755361的博客
06-16 855
C++多继承及虚函数
C++虚函数、多继承和虚基类学习心得
weixin_30300523的博客
12-02 132
前段时间一直在学习C++中对象的内存布局，由于C++中支持多继承和虚继承，使得对象的内存布局可能变得有些复杂，刚开始去学习时会有点摸不着头脑。另外不同的编译器很可能有着不同的内存布局，进一步加大了学习难度。 网上已经有很多讲解内存布局的文章，其中很多讲得很清楚了，如： http://blog.csdn.net/haoel/article/details/1948051 http:/...
[C++]单/多继承体系中的虚函数表
最新发布
m0_75062065的博客
02-04 968
对于单继承体系中的基类派生类中的虚表关系如下：基类有虚函数，所以基类有一个自己的虚表指针，指向自己的虚表，虚表中存放的就是func1()的地址。派生类继承了基类的虚函数，所以有一个自己的虚表指针，指向自己的虚表，因为派生类重写了基类的虚函数，所以虚表中func1()函数的地址与基类不同。同时派生类又增加了一个虚函数，所以他的虚表里面有两个函数地址。
透过汇编另眼看世界之多继承下的虚函数函数调用
Computer Graphics Changes Your Life
11-04 5823
在我的前一篇文章"透过汇编另眼看世界之函数调用"中，我们通过汇编了解了虚函数调用的全部过程。在本文中我将分析多继承的情况下虚函数调用的情况。首先还是写一些简单的代码作为本文分析的例子代码： //the abstract base classclass IBase ...{public:    virtual void func1() = 0;    virtual void func2
C++ - 多继承方式会产生多个虚函数表
weixin_49303682的博客
08-15 2958
1.多重继承可能产生多个虚函数表 代码示例：会产生多个虚函数表 #include <iostream> #include <string> using namespace std; class BaseA { public: virtual void funcA() { cout << "BaseA::funcA()" << endl; } }; class BaseB { public:
C++学习笔记（19）——多继承中的虚函数
学习，思考，记录，分享。
03-21 3392
本博客（http://blog.csdn.net/livelylittlefish）贴出作者（三二一、小鱼）相关研究、学习内容所做的笔记，欢迎广大朋友指正！                                                           多继承中的虚函数                                             
C++多态虚函数表详解(多重继承、多继承情况)
u013043103的博客
08-09 1149
本文关键词：C++ 多态 多继承 多重继承 虚函数表 虚函数指针 动态绑定 概述：C++相对其他面向对象语言来说，之所以灵活、高效。很大程度的占比在于其多态技术和模板技术。C++虚函数表是支撑C++多态的重要技术，它是C++动态绑定技术的核心。 本文章将着重图解虚函数表相关知识，在阅读本文前，博主已经默认你已经学习了C++多态的语法，并且通过代码实践过。 一、多态起手式以及内存分布 假设有一个基类ClassA，一个继承了该基类的派生类ClassB，并且基类中有虚函数，派生类实现了基类的虚函数。 我们在
C++ 多态与虚函数表（二）—— 多继承
行走
08-16 409
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、多继承 2.1 类定义 class Base1 { public: long long ibase1; Base1 ():ibase1 (10) {} vir.
【C++从0到王者】第二十五站：多继承的虚表
青色_忘川的博客
09-01 969
本篇文章着重讲解了多继承与菱形继承的虚表，以及抽象类的使用等方法。也正如抽象类的名字一样，本节内容确实比较抽象。愿可以为读者带来帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值