虚基类、虚函数，对象内存分布

最新推荐文章于 2023-05-24 17:07:07 发布
最新推荐文章于 2023-05-24 17:07:07 发布
阅读量531 收藏
点赞数
分类专栏： C++&&算法 文章标签： class iostream fun

非虚拟继承：
 在派生类对象里，按照继承声明顺序依次分布基类对象，最后是派生类数据成员。
 若基类声明了虚函数，则基类对象头部有一个虚函数表指针，然后是基类数据成员。
 在基类虚函数表中，依次是基类的虚函数，若某个函数被派生类override，则替换为派生类的函数。
 派生类独有的虚函数被加在第一个基类的虚函数表后面。
 
 虚拟继承：
 在派生类对象里，按照继承声明顺序依次分布非虚基类对象，然后是派生类数据成员，最后是虚基类对象。
 若基类声明了虚函数，则基类对象头部有一个虚函数表指针，然后是基类数据成员。
 在基类虚函数表中，依次是基类的虚函数，若某个函数被派生类override，则替换为派生类的函数。
 若直接从虚基类派生的类没有非虚父类，且声明了新的虚函数，则该派生类有自己的虚函数表，在该派生类头部；否则派生类独有的虚函数被加在第一个非虚基类的虚函数表后面。
 直接从虚基类派生的类内部还有一个虚基类表指针，在数据成员之前，非虚基类对象之后（若有的话）。
 虚基类表中第一个值是该派生类起始地址到该表的偏移；之后的值依次是该派生类的虚基类到该表位置的地址偏移。

非虚拟单继承

 class  Base
   {
       virtual   void  Func2()  {cout << " Base " << endl;} 
      int  iBase;
 } ;
 
 class  Derived :  public  Base
   {
 public :
       void  Func2()  {cout << " Derived Func2 called " << endl;} ;
       void  Func3()  {cout << " Derived Func3 called " << endl;} ;
       virtual   void  Func5()  {cout << " Derived Func5 called " << endl;} ;
 
      int  iDerived;
 } ;

1>class Derived size(12):
1> +---
1> | +--- (base class Base)
1> 0 | | {vfptr}
1> 4 | | iBase
1> | +---
1> 8 | iDerived
1> +---
1>Derived::$vftable@:
1> | &Derived_meta
1> |  0
1> 0 | &Derived::Func2
1> 1 | &Derived::Func5

非虚拟多继承

 class  Base
   {
       virtual   void  Func2()  {cout << " Base " << endl;} 
      int  iBase;
 } ;
 
 class  Base1
   {
 public :
       virtual   void  Func1()  {cout << " Base1 Func1 called " << endl;} ;
       virtual   void  Func2()  {cout << " Base1 Func2 called " << endl;} ;
       virtual   void  Func3()  {cout << " Base1 Func3 called " << endl;} ;
      int  iBase1;
 } ;
 
 class  Base2
   {
 public :
       virtual   void  Func2()  {cout << " Base2 Func2 called " << endl;} ;
       virtual   void  Func3()  {cout << " Base2 Func3 called " << endl;} ;
       virtual   void  Func4()  {cout << " Base2 Func4 called " << endl;} ;
      int  iBase2;
 } ;
 
 class  Derived :  public  Base,  public  Base1,  public  Base2
   {
 public :
       void  Func2()  {cout << " Derived Func2 called " << endl;} ;
       void  Func3()  {cout << " Derived Func3 called " << endl;} ;
       virtual   void  Func5()  {cout << " Derived Func5 called " << endl;} ;
      int  iDerived;
 } ;

1>class Derived size(28):
1> +---
1> | +--- (base class Base)
1> 0 | | {vfptr}
1> 4 | | iBase
1> | +---
1> | +--- (base class Base1)
1> 8 | | {vfptr}
1>12 | | iBase1
1> | +---
1> | +--- (base class Base2)
1>16 | | {vfptr}
1>20 | | iBase2
1> | +---
1>24 | iDerived
1> +---
1>Derived::$vftable@Base@:
1> | &Derived_meta
1> |  0
1> 0 | &Derived::Func2
1> 1 | &Derived::Func5
1>Derived::$vftable@Base1@:
1> | -8
1> 0 | &Base1::Func1
1> 1 | &thunk: this-=8; goto Derived::Func2
1> 2 | &Derived::Func3
1>Derived::$vftable@Base2@:
1> | -16
1> 0 | &thunk: this-=16; goto Derived::Func2
1> 1 | &thunk: this-=8; goto Derived::Func3
1> 2 | &Base2::Func4

虚拟单继承

 class  Base
   {
 public :
       virtual   void  Func2()  {} ;
      int  BaseValue;
 } ;
 
 class  Derived :  virtual   public  Base
   {
 public :
       void  Func2()  {} ;
       virtual   void  Func4()  {} ;
      int  DerivedValue;
 } ;

1>class Derived size(20):
1> +---
1> 0 | {vfptr}
1> 4 | {vbptr}
1> 8 | DerivedValue
1> +---
1> +--- (virtual base Base)
1>12 | {vfptr}
1>16 | BaseValue
1> +---
1>Derived::$vftable@Derived@:
1> | &Derived_meta
1> |  0
1> 0 | &Derived::Func4
1>Derived::$vbtable@:
1> 0 | -4
1> 1 | 8 (Derivedd(Derived+4)Base)
1>Derived::$vftable@Base@:
1> | -12
1> 0 | &Derived::Func2

虚拟多继承

 class  Base
   {
       virtual   void  Func2()  {cout << " Base " << endl;} 
      int  iBase;
 } ;
 
 class  Base1
   {
 public :
       virtual   void  Func1()  {cout << " Base1 Func1 called " << endl;} ;
       virtual   void  Func2()  {cout << " Base1 Func2 called " << endl;} ;
       virtual   void  Func3()  {cout << " Base1 Func3 called " << endl;} ;
      int  iBase1;
 } ;
 
 class  Base2
   {
 public :
       virtual   void  Func2()  {cout << " Base2 Func2 called " << endl;} ;
       virtual   void  Func3()  {cout << " Base2 Func3 called " << endl;} ;
       virtual   void  Func4()  {cout << " Base2 Func4 called " << endl;} ;
      int  iBase2;
 } ;
 
 class  Derived :  public   virtual  Base,  public    virtual  Base1,  public   Base2
   {
 public :
       void  Func2()  {cout << " Derived Func2 called " << endl;} ;
       void  Func3()  {cout << " Derived Func3 called " << endl;} ;
       virtual   void  Func5()  {cout << " Derived Func5 called " << endl;} ;
      int  iDerived;
 } ;


1>class Derived size(32):
1> +---
1> | +--- (base class Base2)
1> 0 | | {vfptr}
1> 4 | | iBase2
1> | +---
1> 8 | {vbptr}
1>12 | iDerived
1> +---
1> +--- (virtual base Base)
1>16 | {vfptr}
1>20 | iBase
1> +---
1> +--- (virtual base Base1)
1>24 | {vfptr}
1>28 | iBase1
1> +---
1>Derived::$vftable@Base2@:
1> | &Derived_meta
1> |  0
1> 0 | &Derived::Func2
1> 1 | &Derived::Func3
1> 2 | &Base2::Func4
1> 3 | &Derived::Func5
1>Derived::$vbtable@:
1> 0 | -8
1> 1 | 8 (Derivedd(Derived+8)Base)
1> 2 | 16 (Derivedd(Derived+8)Base1)
1>Derived::$vftable@Base@:
1> | -16
1> 0 | &thunk: this-=16; goto Derived::Func2
1>Derived::$vftable@Base1@:
1> | -24
1> 0 | &Base1::Func1
1> 1 | &thunk: this-=24; goto Derived::Func2
1> 2 | &thunk: this-=24; goto Derived::Func3


菱形虚拟继承

 #include  < iostream > 
 
 using   namespace  std;
 class  Top
   {
 public :
       virtual   void  Func1()  {} ;
      int  TopValue;
 } ;
 
 class  Left:  virtual   public  Top
   {
 public :
       void  Func1()  {} ;
       virtual   void  Func2()  {} 
      int  LeftValue;
 } ;
 
 class  Right:  virtual   public  Top
   {
 public :
       void  Func1()  {} ;
      int  RightValue;
 } ;
 
 class  Derived :  public  Left,  public  Right
   {
 public :
       void  Func1()  {} ;
       void  Func3()  {} 
       virtual   void  Func4()  {} ;
      int  DerivedValue;
 } ;
 
 int  main()
   {
        
               Derived d;

               Derived* pd = &d;

               Top* pt = &d;

               cout<<( int *)pt<<endl;

               cout<<( int *)pd<<endl;


      return   0 ;
 }

1>class Derived size(32):
1> +---
1> | +--- (base class Left)
1> 0 | | {vfptr}
1> 4 | | {vbptr}
1> 8 | | LeftValue
1> | +---
1> | +--- (base class Right)
1>12 | | {vbptr}
1>16 | | RightValue
1> | +---
1>20 | DerivedValue
1> +---
1> +--- (virtual base Top)
1>24 | {vfptr}
1>28 | TopValue
1> +---
1>Derived::$vftable@Left@:
1> | &Derived_meta
1> |  0
1> 0 | &Left::Func2
1> 1 | &Derived::Func4
1>Derived::$vbtable@Left@:
1> 0 | -4
1> 1 | 20 (Derivedd(Left+4)Top)
1>Derived::$vbtable@Right@:
1> 0 | 0
1> 1 | 12 (Derivedd(Right+0)Top)
1>Derived::$vftable@Top@:
1> | -24
1> 0 | &Derived::Func1

如上代码的输出结果表示虚基类指针的地址比派生类指针地址多了24，符合上面列出的对象内存布局。

当通过对象访问基类成员时，无论是否为虚拟继承，都可以再编译时期获得对象内存布局，直接计算出偏移量访问。
当通过指针访问基类成员时，如果是非虚拟继承，直接计算偏移量访问；
如果是虚拟继承，需要先计算出虚基类表指针的偏移地址，再根据指针找到虚基类表，取虚基类表中该项的内容，根据此内容计算虚基类对象的偏移地址，再根据成员在虚基类对象中的偏移地址访问。 
所以一般说来，当从派生类中访问虚基类成员时，应该先强制转化派生类指针为虚基类指针，然后一直使用虚基类指针来访问虚基类成员变量。这样做，可以避免每次都要计算虚基类地址的开销。


虚函数表不一定在派生类对象的首地址，例如当派生类从基类虚拟继承时，派生类如果没有定义新的虚函数，那么在派生类的对象空间中，首先分布的是虚基类表，然后是派生类成员，最后是虚基类对象，虚函数表在虚基类对象开始位置。


 class  Base
   {
 public :
       virtual   void  fun()  {} 
 } ;
 
 class  Derived:  virtual   public  Base
   {
       void  fun()  {} 
      int  i;
 } ;

1>class Derived size(12):
1> +---
1> 0 | {vbptr}
1> 4 | i
1> +---
1> +--- (virtual base Base)
1> 8 | {vfptr}
1> +---
1>Derived::$vbtable@:
1> 0 | 0
1> 1 | 8 (Derivedd(Derived+0)Base)
1>Derived::$vftable@:
1> | -8
1> 0 | &Derived::fun

篮若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
虚函数和虚继承及其在内存中布局
08-03
该资源为虚函数和虚继承及其结合的内存布局的测试，文中写明了有详细测试结果。
C++对象的内存分布和虚函数表
不断完善自己~~Just do it！
11-10 759
c++中一个类中无非有四种成员：静态数据成员和非静态数据成员，静态函数和非静态函数。     1.非静态数据成员被放在每一个对象体内作为对象专有的数据成员。     2.静态数据成员被提取出来放在程序的静态数据区内，为该类所有对象共享，因此只存在一份。     3.静态和非静态成员函数最终都被提取出来放在程序的代码段中并为该类所有对象共享，因此每一个成员函数也只能存在一份代码实体。在c+
c++对象内存布局（虚函数）--上
stormbjm的专栏
04-07 545
对象的影响因素   简而言之，我们一个类可能会有如下的影响因素：   1）成员变量 2）虚函数（产生虚函数表） 3）单一继承（只继承于一个类） 4）多重继承（继承多个类） 5）重复继承（继承的多个父类中其父类有相同的超类） 6）虚拟继承（使用virtual方式继承，为了保证继承后父类的内存布局只会存在一份） 上述的东西通常是C++这门语言在语义方面对对象内部的影响因素，当然，还
c++虚基类在内存中的分布
zhubaohua_bupt的博客
08-03 1560
本文转自http://www.cnblogs.com/cy568searchx/p/3688215.html 今天重温C++的知识，当看到虚基类这点的时候，那时候也没有太过追究，就是知道虚基类是消除了类继承之间的二义性问题而已，可是很是好奇，它是怎么消除的，内存布局是怎么分配的呢？于是就深入研究了一下，具体的原理如下所示： 在C++中，obj是一个类的对象，p是指向obj的指针，该类里面有
浅谈C++对象的内存分布和虚函数表
08-31
C++是一种静态类型的语言，它的内存分配和管理对于理解程序的执行至关重要，特别是涉及到对象的内存分布和虚函数表时。本文将详细探讨这两个主题。 首先，C++对象的内存分布主要涉及对象内部的数据成员和成员函数。...
详谈C++中虚基类在派生类中的内存布局
01-20
今天重温C++的知识，当看到虚基类这点的时候，那时候也没有太过追究，就是知道虚基类是消除了类继承之间的二义性问题而已，可是很是好奇，它是怎么消除的，内存布局是怎么分配的呢？于是就深入研究了一下，具体的...
虚基类与虚函数PPT学习教案.pptx
10-05
虚基类和虚函数是C++面向对象编程中的重要概念，它们主要解决多继承中可能出现的问题，特别是关于共享基类实例和二义性问题。在本篇PPT学习教案中，我们将深入探讨这两个主题。 首先，让我们理解虚基类的概念。在多...
虚基类 虚函数成员 虚析构函数
12-26
在C++编程语言中，虚基类、虚函数成员和虚析构函数是面向对象编程中的关键概念，它们对于理解和实现多态性至关重要。多态性允许我们编写更灵活、可扩展的代码，使得程序能处理多种不同类型的对象。下面将详细解释这...
C++对象内存分布详解(包括字节对齐和虚函数表)
12-31
C++对象的内存分布和虚函数表注意，对象中保存的是虚函数表指针，而不是虚函数表，虚函数表在编译阶段就已经生成，同类的不同对象中的虚函数指针指向同一个虚函数表，不同类对象的虚函数指针指向不同虚函数表。...
C++ 虚继承 虚函数 内存分布
学习笔记
03-03 873
两种实现：http://blog.csdn.net/bluedog/article/details/4711169 虚继承：http://www.oschina.net/translate/cpp-virtual-inheritance 虚函数：http://my.oschina.net/pathenon/blog/67072 当c++支持virtual base class
Cpp 对象模型探索 / 含有虚基类的类的内存布局
布袋和尚
11-04 205
一、栗子 class Grand { public: int i_grand_ = 8; }; class Parent1 : public virtual Grand { public: int i_parent1_ = 9; }; class Parent2 : public virtual Grand { public: int i_parent2_ = 10; }; cla...
虚继承 虚基类的子类内存布局
Y~哈哈哈的博客
03-30 508
1、普通多继承的内存布局 class A { public: int dataA; }; class B : public A { public: int dataB; }; class C : public A { public: int dataC; }; class D : public B, public C { public: int dataD; }; B类的内存...
虚继承与虚基类中对象的内存模型分析
做一个快乐的人
04-26 371
感触：在学习一项内容的时候，我们首先应该对要学习的内容进行详细划分，然后循序渐进的学习划分出来的要点。这样学习起来才会有条理。   什么是虚基类？为什么叫虚基类？ class A{}; class B : virtual public A {}; 此时，称class A为class B的虚基类。虚基类主要是为了和普通的基类相区别，在正常情况下，继承之后，我们说子类中有一个完整的父类对
c++ 虚函数内存布局示意图
chenwh_cn的博客
05-06 1106
文章目录一、virtual 虚函数工作原理二、虚函数内存布局1.基类和派生类同名函数，不能被继承2.单继承，无虚函数覆盖，无新增虚函数i.基类的内存布局：ii.派生类的内存布局：3.单继承，有虚函数覆盖，无新增虚函数4.单继承，有虚函数覆盖，有新增虚函数5.多继承，没有虚函数覆盖，没有新增虚函数6.多继承，有虚函数覆盖，没有新增虚函数7.多继承，有虚函数覆盖，有新增虚函数三、虚函数表指针访问1.代码示例2.安全性i. 通过基类指针访问派生类新增的虚函数ii. 访问 non-public 的虚函数 一、v
虚基类、虚函数和纯虚基类
热门推荐
lovemysea的专栏
02-08 1万+
首先看一个例子：class Base{public:    virtual void print()       //声明虚函数，基类声明了虚函数，子类就不用在virtual了，基类可以传递给子类的同样的函数                                       //基类如果不声明成虚函数，声明成：void print()，则下面的p->print();调用则会调用基类的pr
【C++】虚表和虚基表到底有哪些区别？
qq_40376612的博客
05-24 1556
虚表和虚基表在同时存在时的对象模型
C++基础——虚指针（vptr）与虚基表（vtable）
qq_25065595的博客
07-16 3764
vptr与vtable 手动操作vptr 来访问vtable中的虚函数，如以下测试程序： #include <iostream> #include <memory> using namespace std; typedef void (*func)(void); class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout
c++中的 虚函数 纯虚函数 虚基类
AP1005834的博客
06-27 3999
一、前言     原文转载自 https://blog.csdn.net/a345203172/article/details/21697687，为了理解下C++中虚函数 纯虚函数 虚基类的基础知识点。二、虚函数 纯虚函数 虚基类三者区别          1.虚函数是用于多态中virtual修饰父类函数，确保父类指针调用子类对象时，运行子类函数的。    2.纯虚函数是用来定义接口的，也就是基类...
虚基类和虚函数的区别
最新发布
06-07
虚基类和虚函数是面向对象编程中两个不同的概念，它们在实现多态性时起到关键作用。 **虚函数（Virtual Function）**： 虚函数是在基类中声明为虚的成员函数，当从派生类的对象上调用该函数时，会自动关联到实际的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值