C++ 虚拟继承对象布局

最新推荐文章于 2023-02-16 22:43:59 发布
最新推荐文章于 2023-02-16 22:43:59 发布
阅读量239 收藏
点赞数
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40871466/article/details/104349750
版权

自己做实验的时候发现和一些文章上面的有点不一样。

#include <iostream>
using namespace std;


class B
{
public:
    long ib;
    long cb;//全都定义成 long 这个方便看内存，不然不是对齐的
public:
    B() :ib(0x1010), cb(0x1010) {}
    virtual void f() { cout << "B::f()" << endl; }
    virtual void Bf() { cout << "B::Bf()" << endl; }
};

class B1 : virtual public B
{
public:
    long ib1;
    long cb1;
public:
    B1() :ib1(0x1111111), cb1(0x1111) {}
    //virtual void f() { cout << "B1::f()" << endl; } //为什么要注释掉呢，后面说，不注释掉是失败的 是运行不了的
    virtual void f1() { cout << "B1::f1()" << endl; }
    virtual void Bf1() { cout << "B1::Bf1()" << endl; }
};


int main()
{
    typedef void(*Fun)(void);
    long long** pVtab = NULL;
    Fun pFun = NULL;
    B1 bb1;
    cout<<hex;
    pVtab = (long long**)&bb1;
    cout<<"offset:"<<(long)pVtab-(long)(B*)&bb1<<endl;//因为存在偏移 (B*)&bb1 是不等于 &bb1 这个地址的。
    cout << "[0] B1::_vptr->" << endl;
    for(int i=0;(Fun) pVtab[0][i]!=NULL;i++){
        cout<<"\t["<<i<<"]\t";
        pFun=(Fun)pVtab[0][i];
        pFun();
    }
    cout << "[2] B1::ib1 = ";
    cout << (long)pVtab[1]<< endl; //B1::ib1
    cout << "[3] B1::cb1 = ";
    cout << (long)pVtab[2] << endl; //B1::cb1

    cout << "[3] B::_vptr->" << endl;
    for(int i=0;i<2;i++){ //就是这个地方，如果前面不注释掉就会报错
    //还有你没有没有注意到细节 ，我这个地方写的是 <2 并不是 函数为 空？
        cout<<"\t["<<i<<"]\t";
        pFun=(Fun)(pVtab[3][i]);
        pFun();
    }
    cout << "[4] B::ib1 = ";
    cout << (long)pVtab[4]<< endl; //B1::ib1
    cout << "[5] B::cb1 = ";
    cout << (long)*(pVtab+5) << endl; //B1::cb1
    return 0;
}

输出结果

offset:ffffffffffffffe8
[0] B1::_vptr->
	[0]	B1::f1()
	[1]	B1::Bf1()
[2] B1::ib1 = 1111111
[3] B1::cb1 = 1111
[3] B::_vptr->
	[0]	B::f()
	[1]	B::Bf()
[4] B::ib1 = 1010
[5] B::cb1 = 1010

GDB 调试 查看内存，有意思的来了。

(gdb) p pVtab
$1 = (long long **) 0x7ffdf9b52fc0 //一个B1对象的具体内存
(gdb) x /10xg 0x7ffdf9b52fc0
0x7ffdf9b52fc0:	0x0000562080dd6d08(这个是第一个虚表指针)	0x0000000001111111
0x7ffdf9b52fd0:	0x0000000000001111	0x0000562080dd6d38(第二个虚表指针）
0x7ffdf9b52fe0:	0x0000000000001010	0x0000000000001010
0x7ffdf9b52ff0:	0x0000562080bd61c0	0x0000562080bd617e
0x7ffdf9b53000:	0x00007ffdf9b52fc0	0x0000000200000000

有的文章里面说，虚拟继承每个基类会创建一个虚表，实际上并没有，只是多了一个虚表指针并没有那么多神奇的玩意。
你可以发现两个地址挨着非常近。我们查看 0x0000562080dd6d08这个的内存。

gdb) x /10xg 0x0000562080dd6d08
0x562080dd6d08 <vtable for B1+24>:	0x0000562080bd6146	0x0000562080bd617e
0x562080dd6d18 <vtable for B1+40>:	0x0000000000000000	0x0000000000000000
0x562080dd6d28 <vtable for B1+56>:	0xffffffffffffffe8	0x0000562080dd6d78
0x562080dd6d38 <vtable for B1+72>:	0x0000562080bd607e（第二个虚表指针在这???）	0x0000562080bd60b6
0x562080dd6d48 <VTT for B1>:	0x0000562080dd6d08(有没有发现这个地址就是第一个虚表指针，并没有NULL，所以我那个地方写的是i<2)	0x0000562080dd6d38

看到了吗，实际上全都在B1的虚表里面，只是指针指向的位置不一样。还有个更有意思的。
有没有发现有两个0x0000000000000000目前不知道是啥。0xffffffffffffffe8这个刚好就是偏移量，并没有什么指针直接指向他。所以我不知道虚基表指针是啥，也没看到一个指针算进对象的空间。

然后再继续看这两个虚表指针的内容。

(gdb) x /10xg 0x0000562080bd6146 //不出意外是个函数
0x562080bd6146 <B1::f1()>:	0x10ec8348e5894855	0xfb358d48f87d8948
0x562080bd6156 <B1::f1()+16>:	0x0f003d8d48000000	0x48fffff97be80020
0x562080bd6166 <B1::f1()+32>:	0x200e89058b48c289	0xe8d78948c6894800
0x562080bd6176 <B1::f1()+48>:	0x90c3c990fffff976	0x10ec8348e5894855
0x562080bd6186 <B1::Bf1()+8>:	0xcc358d48f87d8948	0x0ec83d8d48000000

(gdb) x /10xg 0x0000562080bd607e //第二个指针也是
0x562080bd607e <B::f()>:	0x10ec8348e5894855	0xb4358d48f87d8948
0x562080bd608e <B::f()+16>:	0x0fc83d8d48000001	0x48fffffa43e80020
0x562080bd609e <B::f()+32>:	0x200f51058b48c289	0xe8d78948c6894800
0x562080bd60ae <B::f()+48>:	0x90c3c990fffffa3e	0x10ec8348e5894855
0x562080bd60be <B::Bf()+8>:	0x83358d48f87d8948	0x0f903d8d48000001

然后就是更有意思的。记得我们原本注释的吗，我们把他取消注释再来GDB调试。

(gdb) x /10xg 0x000055aec160519d //因为重新运行了地址不一样，我们像那样看第二个虚指针第一项的值
0x55aec160519d <virtual thunk to B1::f()>:	0xebe87a0349178b4c	0xec8348e5894855c0
//看到了  virtual thunk  ，这个告诉我们这个已经被重写了，然后又会调用B1::f()

是不是发现这个布局很像这种写法。

class B{
	A a;
}

当然只是有点像，到了菱形继承就差距很大了。我们继续探索。

#include <iostream>
using namespace std;


#include <iostream>
using namespace std;
class B
{
public:
    long ib;

public:
    B() : ib(0xbbbbb)
    {}

    virtual void
    f()
    {
        cout << "B::f()" << endl;
    }
    virtual void Bf() { cout << "B::Bf()" << endl; }
};

class B1 : virtual public B
{
public:
    long ib1;

public:
    B1() : ib1(0x1111)
    {
    }
    virtual void f(){cout << "B1::f()" << endl;}
    virtual void f1() { cout << "B1::f1()" << endl; }
    virtual void Bf1() { cout << "B1::Bf1()" << endl; }
};

class B2 : virtual public B
{
public:
    long ib2;

public:
    B2() : ib2(0x2222)
    {
    }
//    virtual void f(){cout << "B2::f()" << endl;}
    virtual void f2() { cout << "B2::f2()" << endl; }
    virtual void Bf2() { cout << "B2::Bf2()" << endl; }
};

class D : public B1,
          public B2
{
public:
    long id;
public:
    D() : id(0xdddd)
    {
    }
    virtual void
    f()
    {
        cout << "D::f()" << endl;
    }
    virtual void f1() { cout << "D::f1()" << endl; }
    virtual void f2() { cout << "D::f2()" << endl; }
    virtual void Df() { cout << "D::Df()" << endl; }
};


int main()
{
    typedef void(*Fun)(void);
    long long** pVtab = NULL;
    Fun pFun = NULL;
    D d;

    cout<<"D size:"<<sizeof(d)<<endl;
    cout<<"B1 size:"<<sizeof(B1)<<endl;
    cout<<"D address:"<<&d<<endl;
    cout<<"B1 address:"<<(B1*)&d<<endl;
    cout<<"B1-B2 offset:"<<(long)(B1*)&d-(long)(B2*)&d<<endl;
    cout<<"B2-B offset:"<<(long)(B2*)&d-(long)(B*)&d<<endl;
    cout<<"B address:"<<(B*)&d<<endl;
    pVtab = (long long**)&d;
    cout<<hex;
    cout << "[0] B1::_vptr->" << endl;
    for(int i=0;i<5;i++){
        cout<<"\t["<<i<<"]\t";
        pFun=(Fun)pVtab[0][i];
        pFun();
    }
    cout << "[1] B1::ib1 = ";
    cout << (long)pVtab[1]<< endl;
    cout << "[2] B2::_vptr->" << endl;
    for(int i=0;i<2;i++){
        cout<<"\t["<<i<<"]\t";
        pFun=(Fun)pVtab[2][i];
        pFun();
    }
    cout << "[3] B2::ib2 = ";
    cout << (long)pVtab[3]<< endl;

    cout << "[4] B::ib = ";
    cout << (long)pVtab[4]<< endl;
    cout << "[5] B::_vptr->" << endl;
    for(int i=1;i<2;i++){
        cout<<"\t["<<i<<"]\t";
        pFun=(Fun)pVtab[5][i];
        pFun();
    }
    cout << "[6] B::ib = ";
    cout << (long)pVtab[6]<< endl;
    return 0;
}

运行结果

D size:56
B1 size:32
D address:0x7fff13a26610
B1 address:0x7fff13a26610
B1-B2 offset:-16
B2-B offset:-24
B address:0x7fff13a26638
[0] B1::_vptr->
	[0]	D::f()
	[1]	D::f1()
	[2]	B1::Bf1()
	[3]	D::f2()
	[4]	D::Df()
[1] B1::ib1 = 1111
[2] B2::_vptr->
	[0]	D::f2()
	[1]	B2::Bf2()
[3] B2::ib2 = 2222
[4] B::ib = dddd
[5] B::_vptr->
	[1]	B::Bf()
[6] B::ib = bbbbb

GDB查看内存。

(gdb) x /10xg pVtab
0x7ffc64cadc10:	0x000055c32e665b88(B1的虚指针)	0x0000000000001111
0x7ffc64cadc20:	0x000055c32e665bc8（B2的虚指针）	0x0000000000002222
0x7ffc64cadc30:	0x000000000000dddd（D的数据）	0x000055c32e665bf8(B的虚指针)
0x7ffc64cadc40:	0x00000000000bbbbb	0x0000000000000000
0x7ffc64cadc50:	0x0000000000000000	0x00007ffc64cadc10

看到这应该都清楚了。显然B布局到了最后面。大概就是因为这个所以才能实现只有一份拷贝吧。具体详细分析，自己进去看吧，就是把东西结合起来。
为了方便查看偏移量 我GDB 调试 10进制

(gdb) x /10g pVtab
0x7ffd2687ea70:	94162329979784	4369
0x7ffd2687ea80:	94162329979848	8738
0x7ffd2687ea90:	56797	94162329979896
0x7ffd2687eaa0:	768955	0
0x7ffd2687eab0:	0	140725249895024
(gdb) x /10dg 94162329979784
0x55a3e03acb88 <vtable for D+24>:	94162327877818	94162327877882
0x55a3e03acb98 <vtable for D+40>:	94162327877436	94162327877938
0x55a3e03acba8 <vtable for D+56>:	94162327878000	24（不知道具体怎么排列的，但是知道有就行了）
0x55a3e03acbb8 <vtable for D+72>:	-16	94162329980184
0x55a3e03acbc8 <vtable for D+88>:	94162327877993	94162327877624

(gdb) x /10dg 94162329979848
0x55a3e03acbc8 <vtable for D+88>:	94162327877993	94162327877624
0x55a3e03acbd8 <vtable for D+104>:	0	-40
0x55a3e03acbe8 <vtable for D+120>:	-40	94162329980184
0x55a3e03acbf8 <vtable for D+136>:	94162327877873	94162327877184
0x55a3e03acc08 <VTT for D>:	94162329979784	94162329979992

(gdb) x /10dg 94162329979896
0x55a3e03acbf8 <vtable for D+136>:	94162327877873	94162327877184
0x55a3e03acc08 <VTT for D>:	94162329979784	94162329979992
0x55a3e03acc18 <VTT for D+16>:	94162329980048	94162329980088
0x55a3e03acc28 <VTT for D+32>:	94162329980136	94162329979896
0x55a3e03acc38 <VTT for D+48>:	94162329979848	40

看了好多博客，都搞不懂，自己做出来的和他们有点不一样。
结论你们自己得吧，告辞。

EW_DUST
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++虚继承对象的内存布局
BlueDog专栏
10-22 1万+
c++虚继承对象的内存布局               --VC7.1特别版网上关于c++对象布局的文章挺多，而且《深度探索c++对象模型》(Inside The C++ Object Model 侯捷 译）一书中也很详细地介绍。如果你一点都不了解C++对象的布局,我推荐你看看《深度探索c++对象模型》的第三章,如果你意犹未尽下面的两个系列都很不错：一是陈皓的《C++ 对象的内存布
C++虚继承中的对象内存布局
weixin_34146410的博客
03-09 108
钻石型虚拟继承虚继承是为了解决多继承中的数据冗余而出现的。eg：#define_CRT_SECURE_NO_WARNINGS1 #include<iostream> usingnamespacestd; typedefvoid(*FUNC)(); classBase { public: virtualvoidfun1() { cou...
C++虚拟继承的内存布局
贺生技术专栏
03-29 241
重复继承 下面我们再来看看，发生重复继承的情况。所谓重复继承，也就是某个基类被间接地重复继承了多次。 下图是一个继承图，我们重载了父类的f()函数。 &lt;?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" /&gt; 其类继承的源代码如下所示。其中，每个类都有两个变量，一个是整形（4字节），一个是字符（1字节），而且还有...
虚拟继承内存布局图示
borefo的专栏
09-26 2725
  　　在同时使用了虚函数的时候，虚基类表可以合并到虚表（virtual table）中，每对象的虚基类表指针（vbptr）也可以省略（只需vptr即可）。　　虚函数是C++众多运行时多态特性中开销最小，也最常用的机制。虚函数的好处和作用这里不再多说，应当注意在对性能有苛刻要求的场合，或者需要频繁调用，对性能影响较大的地方（比如每秒钟要调用成千上万次，而自身内容又很简单的事件处理函数）
虚拟继承和虚表
Commander
01-28 1161
普通继承和虚拟继承：
C++对象的内存布局
03-03
不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些内容没有涉及：1）...
C++ 多重继承和虚拟继承对象模型、效率分析
09-04
尽管虚拟继承提高了代码的清晰度和一致性，但它增加了对象模型的复杂性，导致内存布局更复杂，可能会降低访问效率。 在对象模型方面，单一继承通常更简洁，基类成员通常位于派生类成员之前。但在多重继承中，由于...
从汇编看c++的虚拟继承以及其内存布局
12-22
总的来说，虚拟继承主要影响了内存布局和对象构造过程，确保了多个子类共享同一基类实例，解决了菱形继承中的二义性问题。同时，它引入了额外的开销，如虚表指针和可能的内存对齐调整。在没有虚函数的情况下，虚拟...
关于C++中虚拟继承的一些总结分析
09-05
在C++编程语言中，虚拟继承（Virtual Inheritance）是一个重要的特性，主要应用于多重继承的场景。虽然在实际开发中不常见，但理解其工作原理对于深入掌握C++的继承机制至关重要。 1. 虚拟继承的引入原因 虚拟继承...
C++虚拟继承中的对象模型
陈满的专栏
10-30 1507
    最近，从师兄那里听到一道据说是某国内知名IT公司的面试题，有关C++虚拟继承的。#include  using namespace std;class T {//public: //  char ch; //  static  char ch; };class A : virtual public T {}; class B : 
C++ 对象的内存布局（重复虚拟继承）
Robin Hu的专栏
06-28 519
原文：http://blog.csdn.net/haoel/article/details/3081385 下面，让我们来看看重复虚拟继承中C++对象的内存布局的情况，假设有下面这样一个类的继承关系。 虚拟继承的出现就是为了解决重复继承中多个间接父类的问题的。钻石型的结构是其最经典的结构。也是我们在这里要讨论的结构：  上述的“重复继承”只需要把B1和B2继承B的语法中加上virtu
C++ 对象内存模型
一只老风铃
09-12 1515
继承，封装，多态是面向对象的三大特性之一，以类为例，类分为数据成员和函数 而函数分为static、非static、virtual函数三大类函数，那么一般的C++对象其内存模型是如何。 类中存在部分： 成员变量 静态成员变量 成员函数 静态成员函数 构造函数 析构函数 虚函数 虚析构函数 纯虚函数 通常而言对于一个对象，其在内存中的模型不包含函数，只包含成员，而函数单独存放，所有对象通过地址进行调用。对象在内存模型及其占用大小受几方面因素影响： 成员变量 虚表指针 虚基类表指.
C++虚继承内存布局
最新发布
weixin_38255385的博客
02-16 489
虚继承
C++ | 类型转换
@杭大大
10-06 243
static_cast、 const_cast、 dynamic_cast
C++ 对象的内存布局(下)(转)
gxj1680的专栏
07-09 574
C++ 对象的内存布局(下) 陈皓http://blog.csdn.net/haoel  ＜＜＜点击这里查看上篇  重复继承 下面我们再来看看，发生重复继承的情况。所谓重复继承，也就是某个基类被间接地重复继承了多次。 下图是一个继承图，我们重载了父类的f()函数。   其类继承的源代码如下所示。其中，每个类都有两个变量，一个是整形（4字节
c++对象模型05：虚继承内存布局
effort_study的博客
08-07 3120
虚继承 虚继承解决了菱形继承中最派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在： 虚继承的派生类，如果定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。（非虚继承时，派生类新的虚函数直接扩展在基类虚函数表的下面。） 虚继承的派生类有单独的虚函数表，基类也有单独的虚函数表，两部分之间用一个四个字节的0x00000000来作为分界。 虚继承的派生类对象中，含有四字节的虚基表指针。 在C++对象模型中，虚继承而
C++对象之间通信的三种常见方式
Mage的专栏
11-03 1万+
经过这一年多对C++的使用，总结出了下边的三种常见对象之间的通信方式。这里就不上代码了。只作为一种设计思想，记录下来方便自已以后使用，和大家一起学习，这只是自已在工作中的总结，如果谁有更好的经验，请回复我，我再加进去。 1：使用一个全局单例对象作为交互对象的中介； 在这种交互方式中，有三个对象参加进来。 类1：ClassA;             //用来创建交互对象1：obj1 类2：Clas
C++虚拟多重继承对象模型讨论
magictong的专栏
03-26 3950
C++虚拟多重继承对象模型讨论     作者：magictong 调试环境：Windows7VS2005   概述 记得刚开始写C++程序时，那还是大学时光，感觉这玩意比C强大多了，怎么就实现了多态，RTTI这些牛逼的玩意呢？当时没有深究，后来零零散散看过一些介绍的文章，也看了一些相关的书籍，总觉得说得不甚清楚。而这些问题的本质还是在于C++对象的内存模型问题，数据结构决定了你的算法
C++ Virtual详解
热门推荐
悦峰原创博客
05-11 7万+
Virtual是C++ OO机制中很重要的一个关键字。只要是学过C++的人都知道在类Base中加了Virtual关键字的函数就是虚拟函数（例如下面例子中的函数print），于是在Base的派生类Derived中就可以通过重写虚拟函数来实现对基类虚拟函数的覆盖。当基类Base的指针point指向派生类Derived的对象时，对point的print函数的调用实际上是调用了Derived的print函
深度探索C++对象模型_读书笔记1
08-04
然而，虚拟继承则带来不同，它通过一个指针来间接表示父对象，这样做的目的是避免多次存储相同的基类指针，以防止内存碎片和重复存储。这会导致一个额外的间接访问成本，但可以提高代码的灵活性，特别是在多态场景下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值