C++——菱形继承和虚继承

0.关注博主有更多知识

C++知识合集

目录

1.什么是菱形继承和虚继承

2.菱形继承所带来的问题

3.虚继承的解决方案

3.1虚基表

4.继承与组合

菱形继承和虚继承本身就是一个"bug",甚至在C++程序员当中有"谁用谁尚阿比"的说法。至于为什么要谈菱形继承和虚继承,那就是因为面试官要问。

1.什么是菱形继承和虚继承

C++作为"第一个吃螃蟹的人",勇敢地设计出了多继承的语法,多继承出现之后,由于一些顶尖程序员的脑洞非常大,就发现了菱形继承所带来数据冗余和二义性的问题,C++标准委员会为了解决这个问题,就设计出了虚继承。从此之后,后面"抄作业的人"就没有多继承的语法,例如java。

2.菱形继承所带来的问题

先理解一段简单的代码:

/*B、C继承自A---D继承自B、C
 *从而构成菱形继承*/
class A
{
public:
        int _a;
};
class B : public A
{
public:
        int _b;
};
class C : public A
{
public:
        int _c;
};
class D : public B, public C
{
public:
        int _d;
};

int main()
{
        D d;
        //d._a = 3; // 报错,_a不明确
        d.B::_a = 3;
        d.C::_a = 8;
        return 0;
}

这段代码的调试结果为:

这就很好解释了二义性的问题,因为在D类对象当中存在了两份A类对象,所以要访问D类对象中的A类对象时必须指明访问,否则就会触发二义性。如果在某些应用场景中,两份A类对象确实是多余的,那么就又触发了数据冗余问题。所以菱形继承存在数据冗余和二义性的问题。下面给出这段程序的继承关系示意图和D类对象模型示意图:

3.虚继承的解决方案

在介绍如何解决菱形继承的问题之前,先理解一段简单的虚拟单继承的代码:

class A
{
public:
        int _a = 1;
};
class B : virtual public A // virtual为虚继承关键字
{
public:
        int _b = 2;
};
int main()
{
        B b;
        return 0;
}

调试-内存窗口截图如下:

如上图所示,B类对象中的A类对象不再存储成员变量,而是存储一个未知值,这个位置本应该存储A类对象的成员变量,但是A类的成员变量却跑到了B类对象的最后。如此类推,如果再有一个C类虚继承自A类,那么C类对象模型也应该像上图一样。

解决菱形继承的方案就是在继承体系的"腰部"使用虚继承,以下面这段代码为例:

class A
{
public:
    int _a = 1;
};
class B : virtual public A
{
public:
    int _b = 2;
};
class C : virtual public A
{
public:
    int _c = 3;
};
class D : public B, public C
{
public:
    int _d = 4;
};

int main()
{
    D d;
    /*都不报错了,他们操作的都是同一个_a*/
    d._a = 1;
    d.B::_a = 3;
    d.C::_a = 8;
    return 0;
}

最终调试的结果如下:

 

不要被监视窗口所误导,上图三个红色箭头所指向的_a实际上是同一个_a,也就是说D类对象的模型当中只存在一份A类对象了。

通过内存窗口观察D类对象的模型:

 

与之前介绍的一样,B类对象和C类对象当中本该存储A类对象的位置存储了一个随机值。实际上这个随机值是一个指针,它指向了虚基表。

3.1虚基表

对于上面的图片,介绍了所谓的"随机值"是指针,指向了一个名为虚基表的东西,那么再另起一个内存窗口,观察虚基表的构成:

 

由此可见,虚基表存储的有效内容为偏移量,具体的来说,当某一指针或引用指向D类对象时,需要访问_a时,就需要通过虚基表当中的偏移量来确定访问目标的位置。虽然虚基表的存在增加了几次指针的运算,但是试想以下,如果A类对象足够大,在菱形继承体系中不使用虚继承,那么最终的D类对象就会有两份A类对象,并且A类对象是一个巨大的对象,那么如果使用了虚继承,就能将两份A类对象压缩成一份A类对象。

所以使用虚继承,能够解决菱形继承带来的数据冗余和二义性问题。最后以一张图描述D类对象的模型:

 

4.继承与组合

组合的类设计方式是这样的:

class A
{
public:
        int _a;
};
class B
{
public:
        A a;
};

可以明显看出与继承的差别:组合的耦合度更低,继承的耦合度更高。实际上在真实的设计环境当中是很忌讳高耦合的,但是某些场景当中却不得不这么做。

继承是一种is-a的关系,例如下面这个例子:

class Person
{};
class Student : public Person
{};

这个例子所表达的意思就是Student是Person,即学生是人。

组合是一种has-a的关系,例如最开头的那段代码,表达的意思就是B类对象当中有一个A类对象。

针对不同的场景使用不同的复用手段,当条件只允许使用is-a的关系时就使用继承;只允许使用has-a的关系时就使用组合;当既可以使用继承又可以使用组合的关系时使用组合。

为什么要尽量使用组合关系?

因为对于继承来说,它相当于一种白箱复用,即箱子里面的内容能够清清楚楚的看到;对于组合来说,它相当于一种黑箱复用,即箱子里面的内容大多是不可见的,能够看见的也仅仅是一部分(例如设计类时提供给外部的成员函数)。对于继承来说,如果基类的非private成员发生了变动,由于耦合度高的原因,派生类也将会受到影响;对于组合来说,被包含的对象只有public成员发生变动时,才有可能影响到包含该对象的对象。

  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
C++菱形继承是指一个派生类同时继承了两个直接或间接基类,而这两个基类又间接或直接继承自同一个基类,从而形成了一个菱形的继承关系。 例如下面的代码: ``` class A { public: int a; }; class B : public A { public: int b; }; class C : public A { public: int c; }; class D : public B, public C { public: int d; }; ``` 在这个例子中,类 `D` 继承了类 `B` 和类 `C`,而类 `B` 和类 `C` 都继承了类 `A`,因此形成了一个菱形继承关系。 菱形继承会引起一些问题,例如: 1. 内存浪费:由于类 `A` 被重复继承,导致在内存中存在两份相同的 `A` 对象,造成内存浪费。 2. 访问冲突:由于类 `D` 继承了类 `B` 和类 `C`,而这两个类都继承了类 `A`,因此在类 `D` 中访问 `A` 中的成员时会出现访问冲突的问题。 为了解决菱形继承带来的问题,可以使用虚继承虚继承可以解决内存浪费和访问冲突的问题,它的原理是在派生类中只保留一个虚基类的实例,由所有的派生类共享使用。 修改上面的例子,使用虚继承: ``` class A { public: int a; }; class B : virtual public A { public: int b; }; class C : virtual public A { public: int c; }; class D : public B, public C { public: int d; }; ``` 在这个例子中,类 `B` 和类 `C` 继承类 `A` 时使用了 `virtual` 关键字,表示使用虚继承。这样,类 `D` 中就只有一个 `A` 对象的实例,而且访问 `A` 中的成员也不会出现访问冲突的问题。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小龙向钱进

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值