图解C++菱形继承、虚继承对象的内存分布

最新推荐文章于 2023-02-03 22:24:04 发布
最新推荐文章于 2023-02-03 22:24:04 发布
阅读量2.1k 收藏 18
点赞数 10
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AgoniAngel/article/details/105893798
版权

目录

菱形继承的内存分布

虚继承的内存分布

虚继承(有虚函数)的内存分布

菱形继承的构造/析构顺序

虚继承的构造/析构顺序

菱形继承的内存分布

假设继承体系如左图，则 D 的对象内存布局如右图。

【结论】D的对象可以分成3块，每个直接基类(B和C)各占一块，按继承的顺序排放，最后是派生类(D)自己的成员变量。而B和C的数据块中都拷贝了一份间接基类A的数据。

 代码验证：

class A{
public:
    int d = -1;
    int i = 1;
    char c = 'a';
    void f(){cout<<"A::f()"<<endl;}
};
class B: public A{
public:
    int i = 2;      // 覆盖基类
    char c = 'b';   // 覆盖基类
    void f(){cout<<"B::f()"<<endl;}
};
class C: public A{
public:
    char c = 'c';   // 覆盖基类
    int i2 = 3;
    void f(){cout<<"C::f()"<<endl;}
};
class D: public B, public C{
public:
    int j = 4;
    char c = 'd';   // 覆盖基类
};

int main(){
    D x;
    cout<<&x<<" size:\t"<<sizeof(x)<<endl<<endl;

    // A的所有成员都不能显式访问 error: 'A' is an ambiguous base of 'D'
    // x.A::f(); cout<< x.A::d << x.A::c << x.A::i;

    x.B::f();
    cout<<"B::d  "<<&x.B::d       <<"\t"<<x.B::d<<endl
        <<"B::i  "<<&x.B::i       <<"\t"<<x.B::i<<endl
        <<"B::c  "<<(void*)&x.B::c<<"\t"<<x.B::c<<endl<<endl;      // ok

    x.C::f();
    cout<<"C::d  "<<&x.C::d       <<"\t"<<x.C::d<<endl
        <<"C::i  "<<&x.C::i       <<"\t"<<x.C::i<<endl
        <<"C::c  "<<(void*)&x.C::c<<"\t"<<x.C::c<<endl
        <<"C::i2 "<<&x.C::i2      <<"\t"<<x.C::i2<<endl<<endl;     // ok

    cout<<"D::i2 "<<&x.D::i2      <<"\t"<<x.D::i2<<endl
        <<"D::j  "<<&x.D::j       <<"\t"<<x.D::j<<endl
        <<"D::c  "<<(void*)&x.D::c<<"\t"<<x.D::c<<endl<<endl;      // ok

    // D中定义(或覆盖)的成员、继承的唯一性成员可以直接访问,等价于使用 D::
    cout<<"x.i2  "<<&x.i2         <<"\t"<<x.i2<<endl
        <<"x.j   "<<&x.j          <<"\t"<<x.j<<endl
        <<"x.c   "<<(void*)&x.c   <<"\t"<<x.c<<endl<<endl;

    // 有二义性的不能访问
    // cout<<x.d    <<x.i;          // ambiguous
    // cout<<x.D::d <<x.D::i;       // ambiguous
    // x.f(); x.D::f();             // ambiguous

    // 打印不能直接访问的地址
    int* p = &x.B::d;
    cout<<p+1<<"\t"<<*(p+1)<<endl
        <<p+2<<"\t"<<*(char*)(p+2)<<endl;
    p = &x.C::i;
    cout<<p+1<<"\t"<<*(char*)(p+1)<<endl;
}

运行结果：

 

虚继承的内存分布

在上面的菱形继承中，如果直接访问间接基类A的成员，就会出现二义性调用的错误。因为B和C都有一份拷贝，所以必须使用作用域限定符，指定使用哪个直接基类的数据。而使用虚继承可以消除对间接基类A的重复拷贝，使得D的对象中只有一份拷贝。

虚继承的目的是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类（Virtual Base Class），本例中的 A 就是一个虚基类。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含一份虚基类的成员。

使用虚继承得到的派生类(B和C)，它的对象中有隐藏的虚基类表指针(vbptr)指向虚基类表(vbtable)，表中记录了虚基类表指针与虚基类之间的偏移量。而虚基类部分被放到对象内存的最后面。

虚基类表中存放了2个偏移量：

  • 第1个是当前的vbptr 相对于虚函数表指针(vfptr)的偏移量（由于这里没有定义虚函数，也就没有虚表指针，所以偏移量为0）；
  • 第2个是当前的vbptr 相对于虚基类(A)部分的偏移量。

 

假设继承体系如左图，则 D 的对象内存布局如右图。 

代码验证：

class A{
public:
    int d = -1;
    int i = 1;
    char c = 'a';
    void f(){cout<<"A::f()"<<endl;}
};
class B: virtual public A{
public:
    int i = 2;      // 覆盖基类
    char c = 'b';   // 覆盖基类
};
class C: virtual public A{
public:
    char c = 'c';   // 覆盖基类
    int i2 = 3;
    void f(){cout<<"C::f()"<<endl;}
};
class D: public B, public C{
public:
    int j = 4;
};

int main(){
    D x;
    cout<<&x<<" size:\t"<<sizeof(x)<<endl<<endl;

    x.B::f();
    cout<<"B::d  "<<&x.B::d       <<"\t"<<x.B::d<<endl
        <<"B::i  "<<&x.B::i       <<"\t"<<x.B::i<<endl
        <<"B::c  "<<(void*)&x.B::c<<"\t"<<x.B::c<<endl<<endl;      // ok

    x.C::f();
    cout<<"C::d  "<<&x.C::d       <<"\t"<<x.C::d<<endl
        <<"C::i  "<<&x.C::i       <<"\t"<<x.C::i<<endl
        <<"C::c  "<<(void*)&x.C::c<<"\t"<<x.C::c<<endl
        <<"C::i2 "<<&x.C::i2      <<"\t"<<x.C::i2<<endl<<endl;

    x.D::f();
    cout<<"D::d  "<<&x.D::d       <<"\t"<<x.D::d<<endl
        <<"D::i  "<<&x.D::i       <<"\t"<<x.D::i<<endl
        //<<"D::c  "<<(void*)&x.D::c<<"\t"<<x.D::c<<endl        // ambiguous
        <<"D::i2 "<<&x.D::i2      <<"\t"<<x.D::i2<<endl
        <<"D::j  "<<&x.D::j       <<"\t"<<x.D::j<<endl<<endl;

    x.A::f();
    cout<<"A::d  "<<&x.A::d       <<"\t"<<x.A::d<<endl
        <<"A::i  "<<&x.A::i       <<"\t"<<x.A::i<<endl
        <<"A::c  "<<(void*)&x.A::c<<"\t"<<x.A::c<<endl<<endl;

    x.f();
    cout<<"x.d   "<<&x.d          <<"\t"<<x.d<<endl
        <<"x.i   "<<&x.i          <<"\t"<<x.i<<endl
        //<<"x.c   "<<(void*)&x.c   <<"\t"<<x.c<<endl           // ambiguous
        <<"x.i2  "<<&x.i2         <<"\t"<<x.i2<<endl
        <<"x.j   "<<&x.j          <<"\t"<<x.j<<endl<<endl;
}

运行结果：

 

【结论】

  • 虚基类成员的可见性：因为在虚继承的最终派生类中只保留了一份虚基类的成员，所以该成员可以被直接访问，不会产生二义性。此外，如果虚基类的成员只被一条派生路径覆盖，那么仍然可以直接访问这个被覆盖的成员。但是如果该成员被两条或多条路径覆盖了，那就不能直接访问了，此时必须指明该成员属于哪个类。假设 B 定义了一个名为 x 的成员变量，当我们在 D 中直接访问 x 时，会有三种可能性：
    • 如果 B 和 C 中都没有 x 的定义，那么 x 将被解析为 B 的成员，此时不存在二义性。
    • 如果 B 或 C 其中的一个类定义了 x，也不会有二义性，派生类的 x 比虚基类的 x 优先级更高。
    • 如果 B 和 C 中都定义了 x，那么直接访问 x 将产生二义性问题。
  • 使用 x. 和 x.D:: 访问是等价的。

  

虚继承(有虚函数)的内存分布

关于带虚函数的类的内存分布，详见：图解C++虚函数表和类对象的内存分布

这里分析既有虚函数又有虚继承的类的内存分布。

假设继承体系如左图（所有函数均为虚函数），则Derive对象的内存布局如右图。 

【结论】

  • 每个基类(直接基类B1,B2、虚基类A)都有一个虚函数表指针(vfptr)，而直接基类(B1,B2)又都有一个虚基类表指针(vbptr)，虚函数表指针在虚基类表指针的前面。
  • 派生类Derive新定义的虚函数保存在第一个虚函数表中。
  • 每个类的虚函数表都只保存自己新定义的虚函数，继承或重写的虚函数保存在最早定义这个虚函数的类的虚函数表中。
  • 由上一条可知，每个虚函数只出现在一个虚函数表中。
  • 如果虚函数表中的某个函数被子类重写，则表中保存子类版本。

代码验证：

class A {
public:
	virtual void f() { cout << "A::f" << endl; }
	virtual void i() { cout << "A::i" << endl; }
	virtual void j() { cout << "A::j" << endl; }
	int a;
};

class B1 : virtual public A {
public:
	virtual void f() { cout << "B1::f" << endl; }
	virtual void h1() { cout << "B1::h1" << endl; }
	int b1;
};

class B2 : virtual public A {
public:
	virtual void i() { cout << "B2::i" << endl; }
	virtual void h2() { cout << "B2::h2" << endl; }
	int b2;
};

class Derive : public B1, public B2 {
public:
	virtual void f() { cout << "Derive::f" << endl; }
	virtual void h2() { cout << "Derive::h2" << endl; }
	virtual void g() { cout << "Derive::g" << endl; }
	int c;
};

用VS查看Derive内存分布：

                                                   

【注】不同IDE下的内存分布可能不同。比如在CodeBlocks下Derive对象只有28字节，少了B1和B2的vbptr，可能把虚基类表放到了vfptr所指的虚函数表后面（即vfptr和vbptr合并成一个指针，虚基类表和虚函数表合并成一张表）。

 

菱形继承的构造/析构顺序

因为菱形继承的 D 是多继承，所以要遵循多继承的构造/析构顺序，即按继承顺序调用相应基类（B、C）的构造函数，而初始化B、C之前又要分别调用它们的基类（A）的构造函数，所以构造和析构顺序如下：

A()
B()
A()
C()
D()

~D()
~C()
~A()
~B()
~A()

代码验证： 

class A{
public:
    A(){cout<<"A()"<<endl;}
    ~A(){cout<<"~A()"<<endl;}
};
class B: public A{
public:
    B(){cout<<"B()"<<endl;}
    ~B(){cout<<"~B()"<<endl;}
};
class C: public A{
public:
    C(){cout<<"C()"<<endl;}
    ~C(){cout<<"~C()"<<endl;}
};
class D: public B, public C{
public:
    D(){cout<<"D()"<<endl;}
    ~D(){cout<<"~D()"<<endl;}
};

int main(){
    D x;
    cout<<"sizeof(D): "<<sizeof(D)<<endl;
}

运行结果如下。注意到D的对象大小为2字节，这是因为本例中的所有类都是空类，C++规定空类必须占1字节，所以这2个字节分别来自B、C。

 

虚继承的构造/析构顺序

先初始化虚基类（A），再按继承顺序初始化直接基类（B、C）。若有多个虚基类，按声明的顺序依次初始化。析构顺序正好相反。

因此本例的构造/析构顺序为：

A()
B()
C()
D()

~D()
~C()
~B()
~A()

代码验证：

class A{
public:
    A(){cout<<"A()"<<endl;}
    ~A(){cout<<"~A()"<<endl;}
};
class B: virtual public A{
public:
    B(){cout<<"B()"<<endl;}
    ~B(){cout<<"~B()"<<endl;}
};
class C: virtual public A{
public:
    C(){cout<<"C()"<<endl;}
    ~C(){cout<<"~C()"<<endl;}
};
class D: public B, public C{
public:
    D(){cout<<"D()"<<endl;}
    ~D(){cout<<"~D()"<<endl;}
};

int main(){
    D x;
    cout<<"sizeof(D): "<<sizeof(D)<<endl;
}

运行结果如下。注意到D的对象大小为8字节，这是因为它的内存中有2个指针(4字节)，分别对应直接基类B和C。

 【例2】一个更复杂的继承体系：

F的构造和析构顺序：

C()
E()
A()
B()
D()
F()

~F()
~D()
~B()
~A()
~E()
~C()


 

AgoniAngel
关注
  • 10
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多态（五）---菱形继承中的虚函数表详解
董皓宇
12-28 2847
C++多态 菱形继承 虚基表指针与虚基表 我们知道，在虚继承（菱形继承）中，对于类D创建的对象d，为了避免A类中的变量重复，所以，将A类中成员变量放在d对象模型的最下面，由B类与C类各自虚基表指针访问虚基表中偏移量的方式进行访问A类成员变量。 虚函数表指针与虚函数表（虚表） 在类中成员函数实现多态时，需要将成员函数定义为虚函数，所以，在多态的情景下，单继承下会存在一个虚函数表指针，指向成员函数...
图解Java继承内存分配
01-20
继承的基本概念： 　　（1）Java不支持多继承，也是说子类至多只能有一个父类。 　　（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。 　　（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承。 　　（4）子类中定义的成员方法，并且这个方法的名字返回类型，以及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。 　　分析以上程序示例，主要疑惑点是“子类继承父类的成员变量，父类对象是否会实例化？私有成员变量是否会被继承？被继承的成员变量在哪里分配空间？” 　　1：虚拟机加载ExtendsD
菱形继承,多继承,虚继承、虚表的内存结构全面剖析（逆向分析基础）
weixin_30340819的博客
05-07 143
// 声明：以下代码均在Win32_Sp3 VC6.0_DEBUG版中调试通过.. 在逆向还原代码的时候，必须得掌握了菱形继承,多继承,虚继承虚函数的内存虚表结构。所以，这篇文章献给正在学习C++的朋友们。 当然，由于水平有限，必定错漏百出！所以，希望耽误您的时间，恳求您的指点。在这里万分感谢！ 首先，我们定义如下类： class A { public: A() {...
虚函数与虚继承寻踪
coderchen
01-15 1348
非原创，摘自C++前辈(组员)ZMF。 封装、继承、多态是面向对象语言的三大特性，熟悉C++的人对此应该不会有太多异议。C语言提供的struct，顶多算得上对数据的简单封装，而C++的引入把struct“升级”为class，使得面向对象的概念更加强大。继承机制解决了对象复用的问题，然而多重继承又会产生成员冲突的问题，虚继承在我看来更像是一种“不得已”的解决方案。多态让对象具有了运行时特性
C++继承、多继承及菱形继承
weixin_46935110的博客
10-30 1076
C++继承、多继承及菱形继承
虚函数的内存结构，菱形继承的虚函数内存结构
weixin_41066529的博客
05-14 625
https://blog.csdn.net/u010235142/article/details/78307022
C++多继承中菱形继承构造函数与析构函数执行的顺序
刘胡来
05-24 1458
// test1.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "iostream" using namespace std; class A { public:A() { cout<<"A 类构造函数"<<endl; } public:~A() { cout<<"A 类析构函数"<<endl; } }
图解虚函数的内存模型和继承方式，虚函数表指针、虚函数表、多继承、多重继承、菱形继承、虚继承
zxxkkkk的博客
10-29 1868
虚函数、虚函数表指针、虚函数表、多级继承、多重继承、菱形继承
虚函数的复杂（继承）内存布局
Codenange的博客
02-03 688
继承关系一般分为：单继承和多继承，而多继承的出现就又导致了一种特殊的继承关系菱形继承，为了解决菱形继承的冗余和二义性，又有了菱形虚拟继承的解决方案。本篇主要介绍以上四种继承关系的类对象虚函数内存布局。
C++多态虚函数实现原理，对象和虚函数表的内存布局
回头太难
05-17 2605
基本概念 我们知道C++动态多态是用虚函数实现的，而虚函数的实现方式虽说C++标准没有要求，但是基本都是用虚函数表实现的（编译器决定）。所以我们有必要了解一下虚函数表的实现原理。 用virtual关键字声明的成员函数是虚函数。 具有虚函数的类及其派生的类会在编译时创建虚函数表，简称虚表（vtbl），虚表是虚函数指针的数组。 具有虚函数的类对象有一个虚表指针（vfptr），是编译器生成的指针，在对象构造时初始化。虚表指针vfptr指向虚表的第一个虚函数指针（即vfptr的值是虚表第一个...
C++类继承内存布局详解图（一目了然）
07-24
看了这个内存布局图详解之后，对于C++的了解更加深刻了，之前不懂得一头雾水的东西全都清楚了。
C++ 多态 虚表 分析 图解 .doc
07-25
C++ 中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技 术可以让父类的指针有“多种形态”，这是一种泛型技术...
图解C++、CoffeeScript、Ruby复杂度
03-04
虽然CoffeeScript和Ruby都是动态语言，这点明显和C++不同，但它们都是多范例语言，而且（至少某种程度上）支持面向对象、函数式、过程式以及普通编程，所以这篇文章可以简单地理解为C++vs.动态语言。这里拿来比较的...
C语言读取Excel文件
热门推荐
AgoniAngel
03-03 1万+
C语言要读取xls/xlsx格式文件比较复杂，可以先把xls/xlsx格式另存为csv格式。 比如文件"i.csv"内容如下： csv格式采用逗号分隔符，用记事本打开可以看到： 用 fscanf 读取字符串时，注意指定字符串的格式，要用逗号和\n作为分隔符。 (scanf/fscanf等函数指定字符串格式的方法：点击) 代码： #include <stdio.h>...
C语言 打印一个文件夹中所有文件名
AgoniAngel
03-03 1970
#include <stdio.h> #include <io.h> int main(){ const char *path = "D:\\*.csv"; // 输出这个目录下所有csv文件名 //const char *path = "D:\\*"; // 输出这个目录下所有文件和子文件夹的名字 long handle; //用于查找...
图解C++虚函数表和类对象的内存分布
AgoniAngel
04-11 865
1.单继承的内存分布 2.多继承的内存分布 3.菱形继承的内存分布
运算符重载
AgoniAngel
07-20 432
#include using namespace std; class Complex{ public: Complex(double r=0.0,double i=0.0):real(r),imag(i){} Complex operator+(const Complex &c)const{ return Complex(real+c.real,imag+c.i
后端开发是一个涉及广泛技术和工具的领域.docx
最新发布
04-30
后端开发是一个涉及广泛技术和工具的领域，这些资源对于构建健壮、可扩展和高效的Web应用程序至关重要。以下是对后端开发资源的简要介绍： 首先，掌握一门或多门编程语言是后端开发的基础。Java、Python和Node.js是其中最受欢迎的几种。Java以其跨平台性和丰富的库而著名，Python则因其简洁的语法和广泛的应用领域而备受欢迎。Node.js则通过其基于JavaScript的单线程异步I/O模型，为Web开发提供了高性能的解决方案。 其次，数据库技术是后端开发中不可或缺的一部分。关系型数据库（如MySQL、PostgreSQL）和非关系型数据库（如MongoDB、Redis）各有其特点和应用场景。关系型数据库适合存储结构化数据，而非关系型数据库则更适合处理大量非结构化数据。 此外，Web开发框架也是后端开发的重要资源。例如，Express是一个基于Node.js的Web应用开发框架，它提供了丰富的API和中间件支持，使得开发人员能够快速地构建Web应用程序。Django则是一个用Python编写的Web应用框架，它采用了MVC的软件设计模式，使得代码结构更加清晰和易于维护。
C++面向对象——类/抽象 图解
09-03
然而，C语言中的结构体不支持继承和多态等面向对象的特性。 在C语言中，我们可以使用函数指针来模拟抽象类和接口的概念。函数指针可以指向不同的函数，通过使用函数指针，我们可以实现多态性，即在运行时根据函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值