C++ 多继承和虚继承的内存布局

简介: 来源:http://www.oschina.net/translate/cpp-virtual-inheritance 来源:http://www.cnblogs.com/BeyondAnyTime/archive/2012/06/05/2537451.html C++中的虚拟继承的一些总结 1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决

来源:http://www.oschina.net/translate/cpp-virtual-inheritance

来源:http://www.cnblogs.com/BeyondAnyTime/archive/2012/06/05/2537451.html


C++中的虚拟继承的一些总结

1.为什么要引入虚拟继承

虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2,而类B1、B2都继承自类A,因此在类D中两次出现类A中的变量和函数。为了节省内存空间,可以将B1、B2对A的继承定义为虚拟继承,而A就成了虚拟基类。实现的代码如下:

class A

class B1:public virtual A;

class B2:public virtual A;

class D:public B1,public B2;

虚拟继承在一般的应用中很少用到,所以也往往被忽视,这也主要是因为在C++中,多重继承是不推荐的,也并不常用,而一旦离开了多重继承,虚拟继承就完全失去了存在的必要。因为离开了多重继承之后虚拟继承就只会降低效率和占用更多的空间。

2.引入虚继承和直接继承会有什么区别呢

由于有了间接性和共享性两个特征,所以决定了虚继承体系下的对象在访问时必然会在时间和空间上与一般情况有较大不同。

2.1时间:在通过继承类对象访问虚基类对象中的成员(包括数据成员和函数成员)时,都必须通过某种间接引用来完成,这样会增加引用寻址时间(就和虚函数一样),其实就是调整this指针以指向虚基类对象,只不过这个调整是运行时间接完成的。

2.2空间:由于共享所以不必要在对象内存中保存多份虚基类子对象的拷贝,这样较之多继承节省空间。虚拟继承与普通继承不同的是,虚拟继承可以防止出现diamond继承时,一个派生类中同时出现了两个基类的子对象。也就是说,为了保证这一点,在虚拟继承情况下,基类子对象的布局是不同于普通继承的。因此,它需要多出一个指向基类子对象的指针。

3.笔试,面试中常考的C++虚拟继承的知识点

第一种情况:         第二种情况:          第三种情况            第四种情况:
class a           class a              class a              class a
{              {                {                 {
    virtual void func();      virtual void func();       virtual void func();        virtual void func();
};              };                  char x;              char x;
class b:public virtual a   class b :public a           };                };
{              {                class b:public virtual a      class b:public a
    virtual void foo();        virtual void foo();     {                 {
};              };                  virtual void foo();        virtual void foo();
                               };                };

如果对这四种情况分别求sizeof(a),  sizeof(b)。结果是什么样的呢?下面是输出结果:(在vc6.0中运行)
第一种:4,12 
第二种:4,4
第三种:8,16
第四种:8,8

想想这是为什么呢?

因为每个存在虚函数的类都要有一个4字节的指针指向自己的虚函数表,所以每种情况的类a所占的字节数应该是没有什么问题的,那么类b的字节数怎么算呢?看“第一种”和“第三种”情况采用的是虚继承,那么这时候就要有这样的一个指针vptr_b_a,这个指针叫虚类指针,也是四个字节;还要包括类a的字节数,所以类b的字节数就求出来了。而“第二种”和“第四种”情况则不包括vptr_b_a这个指针,这回应该木有问题了吧。

4.c++重载、覆盖、隐藏的区别和执行方式

既然说到了继承的问题,那么不妨讨论一下经常提到的重载,覆盖和隐藏
4.1成员函数被重载的特征
(1)相同的范围(在同一个类中); 
(2)函数名字相同; 
(3)参数不同; 
(4)virtual 关键字可有可无。 
4.2“覆盖”是指派生类函数覆盖基类函数,特征是:
(1)不同的范围(分别位于派生类与基类); 
(2)函数名字相同; 
(3)参数相同; 
(4)基类函数必须有virtual 关键字。 
4.3“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,特征是:

(1)如果派生类的函数与基类的函数同名,但是参数不同,此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。 
(2)如果派生类的函数与基类的函数同名,但是参数相同,但是基类函数没有virtual 关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。

小结:说白了就是如果派生类和基类的函数名和参数都相同,属于覆盖,这是可以理解的吧,完全一样当然要覆盖了;如果只是函数名相同,参数并不相同,则属于隐藏。

4.4 三种情况怎么执行:

4.4.1 重载:看参数。

4.4.2 隐藏:用什么就调用什么。

4.4.3 覆盖:调用派生类。


多重继承

首先我们考虑一个(非虚拟)多重继承的相对简单的例子。看看下面的C++类层次结构。

class Top
{ public: int a;
}; class Left : public Top
{ public: int b;
}; class Right : public Top
{ public: int c;
}; class Bottom : public Left, public Right
{ public: int d;
};
使用UML图,我们可以把这个层次结构表示为:


注意Top被继承了两次(在Eiffel语言中这被称作重复继承)。这意味着类型Bottom的一个实例bottom将有两个叫做a的元素(分别为bottom.Left::a和bottom.Right::a)。

Left、Right和Bottom在内存中是如何布局的?让我们先看一个简单的例子。Left和Right拥有如下的结构:

Left
Top::a
Left::b
   Right
    Top::a
    Right::c

请注意第一个属性是从Top继承下来的。这意味着在下面两条语句后

Left* left = new Left();
Top* top = left;
left和top指向了同一地址,我们可以把Left Object当成Top Object来使用(很明显,Right与此也类似)。那Bottom呢?GCC的建议如下:
Bottom        
Left::Top::a
Left::b
Right::Top::a
Right::c
Bottom::d

如果我们提升Bottom指针,会发生什么事呢?
Bottom* bottom = new Bottom();
Left* left = bottom;

这段代码工作正常。我们可以把一个Bottom的对象当作一个Left对象来使用,因为两个类的内存部局是一样的。那么,如果将其提升为Right呢?会发生什么事?

Right* right = bottom;
为了执行这条语句,我们需要判断指针的值以便让它指向Bottom中对应的段。

Bottom

Left::Top::a

Left::b
rightpoints to  Right::Top::a

Right::c

Bottom::d

经过这一步,我们可以像操作正常Right对象一样使用right指针访问bottom。虽然,bottom与right现在指向两个不同的内存地址。出于完整性的缘故,思考一下执行下面这条语句时会出现什么状况。
Top* top = bottom;
是的,什么也没有。这条语句是有歧义的:编译器将会报错。
error: `Top' is an ambiguous base of `Bottom'
两种方式可以避免这样的歧义
Top* topL = (Left*) bottom;
Top* topR = (Right*) bottom;
执行这两条语句后,topL和left会指向同样的地址,topR和right也会指向同样的地址。

虚拟继承

为了避免重复继承Top,我们必须虚拟继承Top:

class Top
{ public: int a;
}; class Left : virtual public Top
{ public: int b;
}; class Right : virtual public Top
{ public: int c;
}; class Bottom : public Left, public Right
{ public: int d;
};
这就得到了如下的层次结构(也许是你一开始就想得到的)


虽然从程序员的角度看,这也许更加的明显和简便,但从编译器的角度看,这就变得非常的复杂。重新考虑下Bottom的布局,其中的一个(也许没有)可能是:

Bottom

Left::Top::a

Left::b

Right::c

Bottom::d

这个布局的优点是,布局的第一部分与Left的布局重叠了,这样我们就可以很容易的通过一个Left指针访问 Bottom类。可是我们怎么处理

Right* right = bottom;

我们将哪个地址赋给right呢? 经过这个赋值,如果right是指向一个普通的Right对象,我们应该就能使用 right了。但是这是不可能的!Right本身的内存布局是完全不同的,这样我们就无法像访问一个"真正的"Right对象一样,来访问升级的Bottom对象。而且,也没有其它(简单的)可以正常运作的Bottom布局。

解决办法是复杂的。我们先给出解决方案,之后再来解释它。


你应该注意到了这个图中的两个地方。第一,字段的顺序是完全不同的(事实上,差不多是相反的)。第二,有几个vptr指针。这些属性是由编译器根据需要自动插入的(使用虚拟继承,或者使用虚拟函数的时候)。编译器也在构造器中插入了代码,来初始化这些指针。

vptr (virtual pointers)指向一个 “虚拟表”。类的每个虚拟基类都有一个vptr指针。要想知道这个虚拟表 (vtable)是怎样运用的,看看下面的C++ 代码。

Bottom* bottom = new Bottom();
Left* left = bottom; int p = left->a;

第二个赋值使left指向了bottom的所在地址(即,它指向了Bottom对象的“顶部”)。我们想想最后一条赋值语句的编译情况(稍微简化了):

movl left, %eax # %eax = left 
movl (%eax), %eax # %eax = left.vptr.Left 
movl (%eax), %eax # %eax = virtual base offset 
addl left, %eax # %eax = left + virtual base offset 
movl (%eax), %eax # %eax = left.a 
movl %eax, p # p = left.a 

用语言来描述的话,就是我们用left指向虚拟表,并且由它获得了“虚拟基类偏移”(vbase)。这个偏移之后就加到了left,然后left就用来指向Bottom对象的Top部分。从这张图你可以看到Left的虚拟基类偏移是20;如果假设Bottom中的所有字段都是4个字节,那么给left加上20字节将会确实指向a字段。

经过这个设置,我们就可以同样的方法访问Right部分。按这样

Bottom* bottom = new Bottom();
Right* right = bottom; int p = right->a;

之后right将指向Bottom对象的合适的部位:


Bottom

vptr.Left

Left::b
rightpoints to  vptr.Right

Right::c

Bottom::d

Top::a

对top的赋值现在可以编译成像前面Left同样的方式。唯一的不同就是现在的vptr是指向了虚拟表的不同部位:取得的虚拟表偏移是12,这完全正确(确定!)。我们可以将其图示概括:


当然,这个例子的目的就是要像访问真正Right对象一样访问升级的Bottom对象。因此,我们必须也要给Right(和Left)布局引入vptrs:


现在我们就可以通过一个Right指针,一点也不费事的访问Bottom对象了。不过,这是付出了相当大的代价:我们要引入虚拟表,类需要扩展一个或更多个虚拟指针,对一个对象的一个简单属性的查询现在需要两次间接的通过虚拟表(即使编译器某种程度上可以减小这个代价)。

向下转换

如我们所见,将一个派生类的指针转换为一个父类的指针(或者说,向上转换)可能涉及到给指针增添一个偏移。有人可能会想了,这样向下转换(反方向的)就可以简单的通过减去同样的偏移来实现。确实,对非虚拟继承来说是这样的。可是,虚拟继承(毫不奇怪的!)带来了另一种复杂性。

假设我们像下面这个类这样扩展继承层次。
class AnotherBottom : public Left, public Right
{ public: int e; int f;
};

继承层次现在看起来是这样


现在考虑一下下面的代码。

Bottom* bottom1 = new Bottom();
AnotherBottom* bottom2 = new AnotherBottom();
Top* top1 = bottom1;
Top* top2 = bottom2;
Left* left = static_cast<Left*>(top1);

下图显示了Bottom和AnotherBottom的布局,而且在最后一个赋值后面显示了指向top的指针。


Bottom

vptr.Left

Left::b

vptr.Right

Right::c

Bottom::d
top1points to  Top::a

AnotherBottom

vptr.Left

Left::b

vptr.Right

Right::c

AnotherBottom::e

AnotherBottom::f
top2points to  Top::a

现在考虑一下怎么去实现从top1到left的静态转换,同时要想到,我们并不知道top1是否指向一个Bottom类型的对象,或者是指向一个AnotherBottom类型的对象。所以这办不到!这个重要的偏移依赖于top1运行时的类型(Bottom则20,AnotherBottom则24)。编译器将报错:

error: cannot convert from base `Top' to derived type `Left' 
via virtual base `Top'

因为我们需要运行时的信息,所以应该用一个动态转换来替代实现:

Left* left = dynamic_cast<Left*>(top1);

可是,编译器仍然不满意:

error: cannot dynamic_cast `top' (of type `class Top*') to type 
   `class Left*' (source type is not polymorphic)

(注:polymorphic多态的

问题在于,动态转换(转换中使用到typeid)需要top1所指向对象的运行时类型信息。但是,如果你看看这张图,你就会发现,在top1指向的位置,我们仅仅只有一个integer (a)而已。编译器没有包含指向Top的虚拟指针,因为它不认为这是必需的。为了强制编译器包含进这个vptr指针,我们可以给Top增加一个虚拟的析构器:

class Top
{ public: virtual ~Top() {} int a;
};

这个修改需要指向Top的vptr指针。Bottom的新布局是


(当然类似的其它类也有一个新的指向Top的vptr指针)。现在编译器为动态转换插进了一个库调用:

left = __dynamic_cast(top1, typeinfo_for_Top, typeinfo_for_Left, -1);

这个函数__dynamic_cast定义在stdc++库中(相应的头文件是cxxabi.h);参数为Top的类型信息,Left和Bottom(通过vptr.Top),这个转换可以执行。 (参数 -1 标示出Left和Top之间的关系现在还是未知)。更多详细资料,请参考tinfo.cc 的具体实现 。

总结语

最后,我们来看看一些没了结的部分。

指针的指针

这里出现了一点令人迷惑的问题,但是如果你仔细思考下一的话它其实很简单。我们来看一个例子。假设使用上一节用到的类层次结构(向下类型转换).在前面的小节我们已经看到了它的结果:

Bottom* b = new Bottom();
Right* r = b;
(在将b的值赋给r之前,需要将它调整8个字节,从而让它指向Bottom对象的Right部分).因此,我们可以合法地将一个Bottom* 赋值给一个Right*的指针。但是Bottom**和Right**又会怎样呢? 
Bottom** bb = &b;
Right** rr = bb;

编译器会接受这样的形式吗?我们快速测试一下,编译器会报错:

error: invalid conversion from `Bottom**' to `Right**'
为什么呢?假设编译器可以接受从bb到rr的赋值。我们可以只管的看到结果如下: 
 

因此,bb和rr都指向b,并且b和r指向Bottom对象的正确的章节。现在考虑当我们赋值给*rr时会发生什么(注意*rr的类型时Right*,因此这个赋值是有效的):

*rr = b;	


目录
相关文章
|
22小时前
|
存储 编译器 C语言
从C语言到C++_22(继承)多继承与菱形继承+笔试选择题(下)
从C语言到C++_22(继承)多继承与菱形继承+笔试选择题
6 0
|
23小时前
|
Java 编译器 定位技术
从C语言到C++_22(继承)多继承与菱形继承+笔试选择题(中)
从C语言到C++_22(继承)多继承与菱形继承+笔试选择题
9 0
|
23小时前
|
安全 程序员 C语言
从C语言到C++_22(继承)多继承与菱形继承+笔试选择题(上)
从C语言到C++_22(继承)多继承与菱形继承+笔试选择题
10 0
|
2天前
|
C++
c++继承
c++继承
10 0
|
5天前
|
数据安全/隐私保护 C++
C++中的继承技术
C++中的继承技术
|
5天前
|
存储 安全 程序员
C++语言中的内存管理技术
C++语言中的内存管理技术
|
5天前
|
存储 缓存 程序员
C++内存管理:避免内存泄漏与性能优化的策略
C++内存管理涉及程序稳定性、可靠性和性能。理解堆和栈的区别至关重要,其中堆内存需手动分配和释放。避免内存泄漏的策略包括及时释放内存、使用智能指针和避免野指针。性能优化策略则包括减少内存分配、选用合适数据结构、避免深拷贝及缓存常用数据。通过这些最佳实践,可提升C++程序的效率和质量。
|
6天前
|
C++
C++中的继承
C++中的继承
9 0
|
6天前
|
存储 程序员 C++
C++堆内存分配
C++堆内存分配
14 2
|
7天前
|
编译器 C++
【继承】初步了解C++继承
【继承】初步了解C++继承