C++ 内存布局 - Part6: 虚继承

已于 2024-10-17 18:34:31 修改
阅读量881 收藏 14
点赞数 8
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2024-10-17 13:34:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/just_lion/article/details/143000937
版权

1. 关于虚继承

虚继承可以在菱形继承体系中，防止派生类中有多份重复祖基类内容。如下图所示，如果是常规继承，Class Final中会有两份Class Base的内容。通过虚继承，即Derived1 虚继承自Base, Derived2 也虚继承自Base, 那么Final中将最终保留一份Base部分的内容。

2. 代码示例

#include <iostream>

class Base {
public:
    virtual void show() {
        std::cout << "Base::show() called" << std::endl;
    }

    int a = 1;
};

class Derived1 : virtual public Base {
public:
    void show() override {
        std::cout << "Derived1::show() called" << std::endl;
    }

    int b = 2;
};

class Derived2 : virtual public Base {
public:
    void show() override {
        std::cout << "Derived2::show() called" << std::endl;
    }

    int c = 3;
};

class Final : public Derived1, public Derived2 {
public:
    void show() override {
        std::cout << "Final::show() called" << std::endl;
    }

    int d = 4;
};

int main() {
    std::cout << "Base size: " << sizeof(Base) << std::endl;
    std::cout << "Derived1 size: " << sizeof(Derived1) << std::endl;
    std::cout << "Derived2 size: " << sizeof(Derived2) << std::endl;
    std::cout << "Final size: " << sizeof(Final) << std::endl;

    Derived1 d1;
    std::cout << "d1 addr: " << &d1 << std::endl;

    Base *bptr = &d1;
    std::cout << "bptr: " << bptr << std::endl;
    bptr->show();

    Final obj;
    std::cout << "final obj  addr: " << &obj << std::endl;

    Derived1 *d1_ptr = &obj;
    std::cout << "d1_ptr: " << d1_ptr << std::endl;
    d1_ptr->show();

    Derived2 *d2_ptr = &obj;
    std::cout << "d2_ptr: " << d2_ptr << std::endl;
    d2_ptr->show();

    Base *b_ptr = &obj;
    std::cout << "b_ptr: " << b_ptr << std::endl;
    b_ptr->show();

    return 0;
}

运行结果：

Base size: 16
Derived1 size: 32
Derived2 size: 32
Final size: 48
d1 addr: 0x7fffffffe240
bptr: 0x7fffffffe250
Derived1::show() called
final obj  addr: 0x7fffffffe210
d1_ptr: 0x7fffffffe210
Final::show() called
d2_ptr: 0x7fffffffe220
Final::show() called
b_ptr: 0x7fffffffe230
Final::show() called

3. Derived1 对象的内存布局

3.1 查看 Derived1对象的内存

(gdb) p d1
$1 = {<Base> = {_vptr.Base = 0x401158 <vtable for Derived1+56>, a = 1}, _vptr.Derived1 = 0x401138 <vtable for Derived1+24>, b = 2}

注意，虽然Base部分写在了前面，但是对于虚继承，实际内存中Base被放在了后面：

(gdb) x/8x &d1
0x7fffffffe240: 0x00401138      0x00000000      0x00000002      0x00000000
0x7fffffffe250: 0x00401158      0x00000000      0x00000001      0x00000000

可以看到，对象的开头内容是 0x00401138， 也就是_vptr.Derived1 = 0x401138 <vtable for Derived1+24>， 紧接着是Derived1的int b, 然后才是_vptr.Base = 0x401158 <vtable for Derived1+56>，然后是Base的数据成员int a.

3.2 查看虚表

1) 首先查看_vptr.Derived1 = 0x401138 <vtable for Derived1+24>

(gdb) x/x 0x401138
0x401138 <vtable for Derived1+24>:      0x00400c7c
(gdb) x/i 0x00400c7c
   0x400c7c <Derived1::show()>: push   %rbp

可见就是Derived1重写的show()

2) 继续查看 _vptr.Base = 0x401158 <vtable for Derived1+56>

(gdb) x/x 0x401158
0x401158 <vtable for Derived1+56>:      0x00400ca7
(gdb) x/i 0x00400ca7
   0x400ca7 <virtual thunk to Derived1::show()>:        mov    (%rdi),%r10
(gdb) disass 0x00400ca7,+10
Dump of assembler code from 0x400ca7 to 0x400cb1:
   0x0000000000400ca7 <virtual thunk to Derived1::show()+0>:    mov    (%rdi),%r10
   0x0000000000400caa <virtual thunk to Derived1::show()+3>:    add    -0x18(%r10),%rdi
   0x0000000000400cae <virtual thunk to Derived1::show()+7>:    jmp    0x400c7c <Derived1::show()>
   0x0000000000400cb0 <Derived2::show()+0>:     push   %rbp
End of assembler dump.

可以看到，虚表中存放的是thunk代码的地址。

这段thunk代码的用途：当通过基类指针指向Derived1对象时，即Base *bptr = &d1, 由于当前的bptr指向的是Derived1对象中的Base部分（此部分位于对象靠后的位置），而非Derived1对象的真正起始地址，因此通过bptr执行虚函数时，为了执行真正的Derived1中重写的虚函数Derived1::show()，需要调整this指针到Derived1对象的起始地址。

mov    (%rdi),%r10    # rdi中存放的是this指针，也就是指向Base part的指针，而非Derived对象的起始地址, 此操作将this的开头虚表地址条目也就是_vptr.Base = 0x401158 <vtable for Derived1+56> 放入r10

add    -0x18(%r10),%rdi  #  将_vptr.Base的虚表地址-0x18 也就是前移3个条目获取里面存放的offset, 然后将此offset 加到rdi, 执行此操作之前rdi是0x7fffffffe250， offset是0xfffffffffffffff0xf

执行add操作以后，可以得到Derived1对象的起始地址： 0x7fffffffe250 + 0xfffffffffffffff0 = 0x7fffffffe240

(gdb) x/2x 0x401158 - 0x18
0x401140 <vtable for Derived1+32>:      0xfffffff0      0xffffffff

3.3 Derived1 内存布局

 其中虚表中thunk地址前面的条目0x00401200 指向typeinfo

(gdb) x/x 0x00401200
0x401200 <typeinfo for Derived1>:       0x00601d98

4. Final 对象的内存布局

4.1 查看Final对象内存

(gdb) p obj
$22 = {<Derived1> = {<Base> = {_vptr.Base = 0x401060 <vtable for Final+88>, a = 1}, _vptr.Derived1 = 0x401020 <vtable for Final+24>,
    b = 2}, <Derived2> = {_vptr.Derived2 = 0x401040 <vtable for Final+56>, c = 3}, d = 4}

同样，这只是逻辑视图，而不是内存实际布局。

查看实际内存布局：

(gdb) x/12x &obj
0x7fffffffe210: 0x00401020      0x00000000      0x00000002      0x00000000
0x7fffffffe220: 0x00401040      0x00000000      0x00000003      0x00000004
0x7fffffffe230: 0x00401060      0x00000000      0x00000001      0x00000000

顺序依次是Derived1 part, Derived2 part, Base part

4.2 查看虚表

1）首先查看_vptr.Derived1 = 0x401020 <vtable for Final+24>

(gdb) x/32x 0x401020
0x401020 <vtable for Final+24>: 0x00400ce4      0x00000000      0x00000010      0x00000000
0x401030 <vtable for Final+40>: 0xfffffff0      0xffffffff      0x00401188      0x00000000
0x401040 <vtable for Final+56>: 0x00400d18      0x00000000      0xffffffe0      0xffffffff
0x401050 <vtable for Final+72>: 0xffffffe0      0xffffffff      0x00401188      0x00000000
0x401060 <vtable for Final+88>: 0x00400d0f      0x00000000      0x00401020      0x00000000
0x401070 <VTT for Final+8>:     0x004010b8      0x00000000      0x004010d8      0x00000000
0x401080 <VTT for Final+24>:    0x004010f8      0x00000000      0x00401118      0x00000000
0x401090 <VTT for Final+40>:    0x00401060      0x00000000      0x00401040      0x00000000
(gdb) x/i 0x00400ce4
   0x400ce4 <Final::show()>:    push   %rbp

可见虚表中的虚函数地址就是<Final::show()>

2） 继续查看_vptr.Derived2 = 0x401040 <vtable for Final+56>

(gdb) x/x 0x401040
0x401040 <vtable for Final+56>: 0x00400d18
(gdb) x/i 0x00400d18
   0x400d18 <non-virtual thunk to Final::show()>:       sub    $0x10,%rdi
(gdb) disass 0x00400d18,+10
Dump of assembler code from 0x400d18 to 0x400d22:
   0x0000000000400d18 <non-virtual thunk to Final::show()+0>:   sub    $0x10,%rdi
   0x0000000000400d1c <non-virtual thunk to Final::show()+4>:   jmp    0x400ce4 <Final::show()>

End of assembler dump.

可以看到，当使用Derived2 *d2_ptr = &obj 来调用虚函数d2_ptr->show();时，需要调整this 指针，但是这个调整比较简单，就是用当前指向Derived2 part的this指针减去0x10

3) 继续查看_vptr.Base = 0x401060 <vtable for Final+88>

(gdb) x/x 0x401060
0x401060 <vtable for Final+88>: 0x00400d0f
(gdb) x/i 0x00400d0f
   0x400d0f <virtual thunk to Final::show()>:   mov    (%rdi),%r10
(gdb) disass 0x00400d0f,+10
Dump of assembler code from 0x400d0f to 0x400d19:
   0x0000000000400d0f <virtual thunk to Final::show()+0>:       mov    (%rdi),%r10
   0x0000000000400d12 <virtual thunk to Final::show()+3>:       add    -0x18(%r10),%rdi
   0x0000000000400d16 <virtual thunk to Final::show()+7>:       jmp    0x400ce4 <Final::show()>

这个就类似于上面讨论Derived1内存布局时通过基类指针操作虚函数时的this指针调整。

4.3 Final 内存布局

其中虚表中thunk地址前面的条目0x00401188指向typeinfo ：

(gdb) x/i 0x00401188
   0x401188 <typeinfo for Final>:       cwtl

C++中virtual继承的深入理解
09-05
本篇文章是对C++中的virtual继承进行了详细的分析介绍，需要的朋友参考下
关于C++中菱形继承和虚继承的问题总结
01-01
前言 菱形继承是多重继承中跑不掉的，Java拿掉了多重继承，辅之以接口。C++中虽然没有明确说明接口这种东西，但是只有纯虚函数的类可以看作Java中的接口。在多重继承中建议使用“接口”，来避免多重继承中可能出现的各种问题。本文将给大家详细介绍关于C++菱形继承和虚继承的相关内容，分享出来供大家参考学习，话不多说了，来一起看看详细的介绍吧。 继承：       1. 单继承–一个子类只有一个直接父类时称这个继承关系为单继承       2. 多继承–一个子类有两个或以上直接父类时称这个继承关系为多继承 例如下面这两个例子： 例一（单继承）： class A { public: int _a;
一文读懂C++虚继承的内存模型_一文读懂虚继承的内存模型
最新发布
2501_90433232的博客
02-04 609
// 现在不会冲突了。
c++虚继承对象的内存布局
热门推荐
BlueDog专栏
10-22 1万+
c++虚继承对象的内存布局               --VC7.1特别版网上关于c++对象布局的文章挺多，而且《深度探索c++对象模型》(Inside The C++ Object Model 侯捷 译）一书中也很详细地介绍。如果你一点都不了解C++对象的布局,我推荐你看看《深度探索c++对象模型》的第三章,如果你意犹未尽下面的两个系列都很不错：一是陈皓的《C++ 对象的内存布
C++ - Memory Layout of Virtual Inherit (虚继承的内存布局)
程序 = 实践 + 思考 (Programming = Practice + Thinking)
03-28 1179
Virtual Table是如何实现的呢？   1. single inherit的简单情况   A virtual table is a static look up array that the compiler sets up at compile time. A virtual table contains one entry for each virtual function
C++虚继承的内存结构
BUPT_LX的专栏
11-04 1050
我用vc2003观测到的实际情况是。在类中增加一个指针(VBPTR)指向一个VBTBL，这个VBTBL的第一项记载的是从VBPTR 与本类的偏移地址，如果本类有虚函数，那么第一项是FF FF FF FC(也就是-4)，如果没有则是零，第二项起是VBPTR与本类的虚基类的偏移值。vc2003的这种方案个人觉得没有Bjarne的好，一是要多一个指针，二是因为VBPTR与虚函数表分开设计，也不便于修改。
虚继承之单继承的内存布局
weixin_30263073的博客
10-10 165
C＋＋2.0以后全面支持虚函数与虚继承，这两个特性的引入为C＋＋增强了不少功能，也引入了不少烦恼。虚函数与虚继承有哪些特性，今天就不记录了，如果能搞了解一下编译器是如何实现虚函数和虚继承，它们在类的内存空间中又是如何布局的，却可以对C＋＋的了解深入不少。这段时间花了一些时间了解这些玩意，搞得偶都，不过总算有些收获，嘿嘿。 先看一段代码class A{ virtual aa(){};};...
C++ 虚继承
06-15 1640
为了解决从不同途径继承来的同名的数据成员在内存中有不同的拷贝造成数据不一致问题，将共同基类设置为虚基类。这时从不同的路径继承过来的同名数据成员在内存中就只有一个拷贝，同一个函数名也只有一个映射。这样不仅就解决了二义性问题，也节省了内存，避免了数据不一致的问题。 class 派生类名：virtual 继承方式 基类名 virtual是关键字，声明该基类为派生类的虚基类。 在多继承情况下，虚基类关
c++对象模型05：虚继承内存布局
effort_study的博客
08-07 3855
虚继承 虚继承解决了菱形继承中最派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在： 虚继承的派生类，如果定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。（非虚继承时，派生类新的虚函数直接扩展在基类虚函数表的下面。） 虚继承的派生类有单独的虚函数表，基类也有单独的虚函数表，两部分之间用一个四个字节的0x00000000来作为分界。 虚继承的派生类对象中，含有四字节的虚基表指针。 在C++对象模型中，虚继承而
C++ 内存布局虚继承 ---Empty virtual base classs (空虚基类)
12-16
C++ 内存布局虚继承 ---Empty virtual base classs (空虚基类).doc
深入解析C++内存布局：5个技巧掌握对象模型与性能优化
[C++内存布局](https://img-blog.csdnimg.cn/87f29f2c50b9446dac08ccd74b3de20c.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbWFuamloZQ==,size_...
C++虚基类进阶课程：3个优化技巧，提升继承体系的性能与稳定性
然而，在复杂的继承体系中，某些设计问题如“菱形继承”会导致子类对象在内存中拥有重复的基类子对象，这不仅影响内存效率，也增加了系统维护的复杂性。为了应对这样的问题，C++引入了虚基类的概念。 虚基类的主要...
C++ 继承和派生
weixin_44599993的博客
11-23 411
继承和派生 继承的前提：分类 聚集(aggregation) 对于那些有明显层次之分的类，在构造后代类对象的时候，不是在其中包含一个前驱类对象，而是在前驱类对象的基础上，在其后面直接添加新的特征。这使得后代对象完全将前驱对象融合在自己内部，而且，每一个后代的前面部分就是一个完整的上一代前驱的对象 在C++和其它面向对象的语言中，聚集的实现过程被称为“继承(inheritance)”和“派生(de...
【C++编程入门基础】：零基础快速掌握C++基本语法
[【C++编程入门基础】：零基础快速掌握C++基本语法](https://fastbitlab.com/wp-content/uploads/2022/07/Figure-6-5-1024x554.png) # 1. C++编程入门基础 ## 1.1 开启C++之旅 C++是一种高级编程语言，它不仅具有...
多态性和虚函数【C++】
qq_45783047的博客
07-31 441
多态性和虚函数【C++】 一、多态性的概念 1、绑定 把函数体和函数调用相联系称为绑定。程序自身彼此关联的过程，也就是把一个标识符名和 一个存储地址联系在一起的过程。按照绑定进行的阶段不同，可以分为两种不同的绑定方法：静态 绑定和动态绑定。 2、静态绑定（静态联编） 联编工作出现在编译阶段，用对象名或者类名来限定要调用的函数。 C++ 中，默认的函数调用绑定方式为早绑定，也叫静态绑定，即在程序运行之前，由编译器 和连接器实现。 3、动态绑定...
C++ 多继承和虚继承的内存布局
jschen10的专栏
10-18 1310
警告. 本文有点技术难度，需要读者了解C++和一些汇编语言知识。 在本文中，我们解释由gcc编译器实现多继承和虚继承的对象的布局。虽然在理想的C++程序中不需要知道这些编译器内部细节，但不幸的是多重继承（特别是虚拟继承）的实现方式有各种各样的不太明确的结论（尤其是，关于向下转型指针，使用指向指针的指针，还有虚拟基类的构造方法的调用命令）。 如果你了解多重继承是如何实现的，你就能预见到这些
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值