个人中心
gpt4 book ai didi

关于C++虚继承的内存模型问题

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 28 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章关于C++虚继承的内存模型问题由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、前言

C++虚继承的内存模型是一个经典的问题，其具体实现依赖于编译器，可能会出现较大差异，但原理和最终的目的是大体相同的。本文将对g++中虚继承的内存模型进行详细解析.

2、多继承存在的问题

C++的多继承是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。从概念上来讲这是非常简单的，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突就是不可回避的一个，比如典型的是菱形继承，如图2-1所示:

关于C++虚继承的内存模型问题

图2-1 菱形继承

在图2-1中，类A派生出类B和类C，类D继承自类B和类C，这个时候类A中的成员变量和成员函数继承到类D中变成了两份，一份来自A–>B–>D这条路径，另一份来自A–>C–>D这条路径。 在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的，因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突。假如类A有一个成员变量a，那么在类D中直接访问a就会产生歧义，编译器不知道它究竟来自A -->B–>D这条路径，还是来自A–>C–>D这条路径。下面是菱形继承的代码实现:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <stdint.h>
 
class A
{
public :
     long a;
};
 
class B: public A
{
public :
     long b;
};
 
 
class C: public A
{
public :
     long c;
};
 
class D: public B, public C
{
public :
     void seta( long v) { a = v; } // 命名冲突
     void setb( long v) { b = v; } // 正确
     void setc( long v) { c = v; } // 正确
     void setd( long v) { d = v; } // 正确
 
private :
     long d;
};
 
int main( int argc, char * argv[])
{
     D d;
}

这段代码就是图2-1所示的菱形继承的具体实现，可以看到在类D的seta()方法中，代码试图直接访问间接基类的成员变量a，结果发生了错误，因为类B和类C中都有成员变量a（都是从类A继承的），编译器不知道选用哪一个，所以产生了歧义.

为了消除歧义，我们可以在使用a时指明它具体来自哪个类，代码如下:

?
1
2
3
void seta( long v) { B::a = v; }
/* 或 */
void seta( long v) { C::a = v; }

使用GDB查看变量d的内存布局，如图2-2所示:

关于C++虚继承的内存模型问题

图2-2 变量d的GDB调试结果

于是我们可以画出变量d的内存布局，如图2-3所示:

关于C++虚继承的内存模型问题

图2-3 变量d的内存布局

3、虚继承简介

为了解决多继承时命名冲突和冗余数据的问题，C++提出了虚继承这个概念，虚继承可以使得在派生类中只保留一份间接基类的成员。使用方式就是在继承方式前面加上virtual关键字修饰，示例代码如下（基于前面的例子修改）:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <stdint.h>
 
class A
{
public :
     long a;
};
 
class B: virtual public A
{
public :
     long b;
};
 
 
class C: virtual public A
{
public :
     long c;
};
 
class D: public B, public C
{
public :
     void seta( long v) { a = v; } // 现在不会冲突了
     void setb( long v) { b = v; } // 正确
     void setc( long v) { c = v; } // 正确
     void setd( long v) { d = v; } // 正确
 
private :
     long d;
};
 
int main( int argc, char * argv[])
{
     D d;
}

可以看到这段代码使用虚继承重新实现了前面提到的那个菱形继承，这样在派生类D中就只保留了一份间接基类A的成员变量a了，后续再直接访问a就不会出现歧义了。虚继承的目的是让某个类做出声明，承诺愿意共享它的基类，这个被共享的基类就称为虚基类（Virtual Base Class），本例中的类A就是一个虚基类。在这种机制下，不论虚基类在继承体系中出现了多少次，在派生类中都只包含一份虚基类的成员。本例的继承关系如图3-1所示:

关于C++虚继承的内存模型问题

图3-1 虚继承下菱形继承

从这个新的继承体系中我们可以发现虚继承的一个特征：必须在虚派生的真实需求出现前就已经完成虚派生的操作。在图3-1中，我们是当定义类D时才出现了对虚派生的需求，但是如果类B和类C不是从类A虚派生得到的，那么类D还是会保留间接基类A的两份成员，示例代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <stdint.h>
 
class A
{
public :
     long a;
};
 
class B: public A
{
public :
     long b;
};
 
 
class C: public A
{
public :
     long c;
};
 
class D: virtual public B, virtual public C
{
public :
     void seta( long v) { a = v; } // 错误，不能等到定义类D时再来做虚继承的工作
     void setb( long v) { b = v; } // 正确
     void setc( long v) { c = v; } // 正确
     void setd( long v) { d = v; } // 正确
 
private :
     long d;
};
 
int main( int argc, char * argv[])
{
     D d;
}

换个角度讲，虚派生只影响从指定了虚基类的派生类中进一步派生出来的类，它不会影响派生类本身。在实际开发中，位于中间层次的基类将其继承声明为虚继承一般不会带来什么问题。通常情况下，使用虚继承的类层次是由一个人或者一个项目组一次性设计完成的。对于一个独立开发的类来说，很少需要基类中的某一个类是虚基类，况且新类的开发者也无法改变已经存在的类体系.

4、虚继承在标准库中的使用

C++标准库中的iostream就是一个虚继承的典型案例。iostream是从istream和ostream直接继承而来的，而istream和ostream又都继承自一个名为ios的类，这个就是一个典型的菱形继承。此时istream和ostream必须采用虚继承，否则将导致iostream中保留两份ios的成员.

iostream相关的源代码如下（从gcc-2.95.3版本中摘录出来的，内容有所省略）:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
struct _ios_fields
{ // The data members of an ios.
     streambuf *_strbuf;
     ostream* _tie;
     int _width;
     __fmtflags _flags;
     _IO_wchar_t _fill;
     __iostate _state;
     __iostate _exceptions;
     int _precision;
 
     void *_arrays; /* Support for ios::iword and ios::pword. */
};
 
class ios : public _ios_fields
{...};
 
class istream : virtual public ios
{...};
 
class ostream : virtual public ios
{...};
 
class iostream : public istream, public ostream
{
public :
     iostream() { }
     iostream(streambuf* sb, ostream*tied=NULL);
};

5、虚继承下派生类的内存布局解析

g++中是没有所谓的虚基类表的（据说vs是有单独一个虚基类表的），只有一个虚表，由于平时用的比较多的是虚函数，所以一般情况下都直接管它叫做虚函数表，在g++编译环境下这种叫法其实是不严谨的。测试程序如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <iostream>
#include <stdint.h>
 
class A
{
public :
     long a;
};
 
class B: virtual public A
{
public :
     long b;
};
 
class C: virtual public A
{
public :
     long c;
};
 
class D: public B, public C
{
public :
     void seta( long v) { a = v; }
     void setb( long v) { b = v; }
     void setc( long v) { c = v; }
     void setd( long v) { d = v; }
 
private :
     long d;
};
 
int main( int argc, char * argv[])
{
     D d;
     d.seta(1);
     d.setb(2);
     d.setc(3);
     d.setd(4);
}

类D在当前编译器(GCC 4.8.5)下的内存布局如图5-1所示:

关于C++虚继承的内存模型问题

图5-1 类D的内存布局

从图5-1中可以看出这个表和之前这篇文章《一文读懂C++虚函数的内存模型》讲的虚函数表是差不多的，就多了一个vbase_offset而已。因为这里的类设计比较简单，没有把虚函数加进来，有虚函数的话_vptr.B或者_vptr.C下面的内存空间存储的就是指向对应虚函数的指针了（以下只讲_vptr.B的相关内容，_vptr.C同理就不赘述了）.

这里可以看到_vptr.B指向的是虚函数的起始地址（因为这里没有虚函数，所以下面紧接着就是_vptr.C的内容），而不是与它相关联的全部信息的起始地址，事实上从图5-1中可以看出_vptr.B - 3 ~ _vptr.B这个范围内的数据都是类B虚表的内容（不知道编译器为什么这么设计，这里也进行揣测了），这三个特殊的内存地址存储的内容解析如下:

_vptr.B - 1：这里存储的是typeinfo for D，里面的内容其实也是一个指针，指向的是类D的运行时信息，这些玩意都是为了支持RTTI的。RTTI的相关内容以后会讲，这里就先不多分析了。_vptr.B - 2：这里存储的是offset_to_top，这个表示的是当前的虚表指针距离类开头的距离，可以看到对于_vptr.B来说这个值就是0，因为_vptr.B就存在于类D的起始位置，而对于_vptr.C来说这个值是-16，大家可以算一下_vptr.C与类D的起始位置确实是差两个地址也就是16个字节（64位系统），至于为什么是负数，这是因为堆内存是向下增长的，越往下地址数值越大.

offset_to_top深度解析：在多继承中，由于不同基类的起点可能处于不同的位置，因此当需要将它们转化为实际类型时，this指针的偏移量也不相同。由于实际类型在编译时是未知的，这要求偏移量必须能够在运行时获取。实体offset_to_top表示的就是实际类型起始地址到当前这个形式类型起始地址的偏移量。在向上动态转换到实际类型时（即基类转派生类），让this指针加上这个偏移量即可得到实际类型的地址。需要注意的是，由于一个类型即可以被单继承，也可以被多继承，因此即使只有单继承，实体offset_to_top也会存在于每一个多态类型之中。 （这里要注意一点就是offset_to_top只存在于多态类型中，所以我们可以看到在第二小节那个例子中，根本就没有什么所谓的虚表之类的东西，它也就不支持RTTI，最简单的大家可以使用dynamic_cast去试试，会报错说该类型不具备多态性质的。那么问题来了，怎样才能以最简短的方式让它具备多态的性质呢？很简单，定义一个析构函数，用virtual修饰即可） 。

_vptr.B - 3：这里存储的是vbase_offset，这个表示的是当前虚表指针与其对应的虚基类的距离。从图中可以看出对于_vptr.B来说这个值是40，算一下刚好是_vptr.B与a的差距，_vptr.C同理.

vbase_offset深度解析：以测试程序为例，对于类型为B的引用，在编译时，无法确定它的虚基类A它在内存中的偏移量。因此，需要在虚表中额外再提供一个实体，表明运行时它的基类所在的位置，这个实体称为vbase_offset，位于offset_to_top上方.

接下来我们通过GDB来验证一下前面讲的内容，先打印出变量d的内存信息，如图5-2所示:

关于C++虚继承的内存模型问题

图5-2 变量d的内存信息

从图5-2中可以看到变量d的内容与前面分析的差不多，接下来我们来看一下这两个虚表的内容，如图5-3所示:

关于C++虚继承的内存模型问题

图5-3 虚表内存信息

从图5-3中可以看出前面的内存图是正确的，接下来就再看一下变量d自身的内存布局，如图5-4所示:

关于C++虚继承的内存模型问题

图5-4 变量d的内存布局

图5-4显示出的结果和前面图5-1的完全一致，到这里调试就结束了，由调试结果可以知道图5-1的内存模型是正确的.

这里要补充一点，就是对于虚继承下的类D，和第二节那个没有虚继承的相比，基类A的位置被移动到了类D的最末尾，不过不用担心，运行时可以靠vbase_offset找到它.

6、总结 。

本文先是对虚继承的概念以及使用场景进行了说明，然后通过一个内存模型图向大家展示了g++下虚继承的内存形态，最后使用GDB查看实际的内存情况来验证内存模型图的正确性。本文为了更直观地展示虚继承的内存模型，示例设计得很简单，类的设计中只有一个成员变量而没有成员函数、虚函数等其它内容。本文与前文《一文读懂C++虚函数的内存模型》相当于抛砖引玉，为下文作铺垫，在下一篇文章中我将对一些稍微复杂一点的情景进行分析，看看完整形态的虚表究竟是什么样的.

到此这篇关于关于C++虚继承的内存模型问题的文章就介绍到这了,更多相关C++虚继承的内存模型内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://blog.csdn.net/weixin_43798887/article/details/118369498 。

最后此篇关于关于C++虚继承的内存模型问题的文章就讲到这里了,如果你想了解更多关于关于C++虚继承的内存模型问题的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

28 4 0
文章推荐： php多文件打包下载的实例代码
文章推荐： 预约云顶之奕手游抽Q币 亲测88Q币
文章推荐： iOS整个APP实现灰色主题的示例代码
文章推荐： 沙雕而又仙女的个性签名 可爱的女生必备的萌萌签名大全
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com