C++ 中虚继承与非虚继承的对比分析

于 2025-05-08 12:04:17 发布
阅读量415 收藏 17
点赞数 16
分类专栏： C++回顾 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47355554/article/details/147785018
版权

C++ 中虚继承与非虚继承的对比分析

相同点

  1. 继承机制基础
    虚继承和非虚继承均属于 C++ 的继承机制，均允许派生类访问基类的成员（包括数据和函数），并支持多态性。
  2. 代码复用
    两者均通过继承实现代码复用，派生类可以直接使用基类的功能，减少重复代码。
  3. 多态性支持
    若基类包含虚函数，无论是否虚继承，均可通过基类指针或引用调用派生类的重写函数。

不同点

维度虚继承非虚继承
内存布局引入虚基类指针（vbptr），指向虚基类表（vbtable），增加内存开销直接包含基类子对象，无额外指针
构造函数调用虚基类的构造函数由最底层的派生类直接调用每个直接基类的构造函数由其直接派生类调用
访问方式通过虚基类表间接访问基类成员直接访问基类成员，无间接寻址
多重继承冲突解决菱形继承问题，确保基类只存在一个实例菱形继承时基类重复实例化，导致数据冗余
性能开销间接访问导致额外开销，适用于复杂继承场景直接访问效率更高，适合简单继承结构

虚继承的核心作用

  1. 解决菱形继承问题
    在多重继承中，若多个中间类继承自同一个基类（如 B 和 C 继承自 A，D 继承 B 和 C），虚继承确保 A 只有一个实例，避免二义性和内存冗余。
    ​示例​：

    class A { int data; };
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};  // D 中仅一个 A 实例

  2. 消除成员访问二义性
    非虚继承下，若基类成员被多次继承，需通过作用域运算符（如 obj.B::data）显式指定路径；虚继承后可直接访问（obj.data）。

虚继承的典型使用场景

  1. 菱形继承结构
    当类层次需通过多重继承形成“菱形”拓扑时，必须使用虚继承避免基类重复。
  2. 共享基类状态
    若多个派生类需共享基类的同一份数据（如全局配置），虚继承可保证数据一致性。
  3. 复杂框架设计
    在 GUI 框架、接口组合等场景中，虚继承可简化类关系的复杂性。

总结

  • 非虚继承：适用于单继承或不存在公共基类的多重继承，追求高效、简单的内存布局。
  • 虚继承：专为菱形继承设计，通过共享基类实例解决数据冗余和二义性，代价是内存和性能开销。
    实际开发中，​优先避免过度多重继承，仅在必要时使用虚继承。

C++菱形继承问题和虚继承分析

C++菱形继承问题和虚继承分析

二义性

在面向对象中，常常存在这样的事情，一个派生类它有两个或两个以上的基类，这种行为称作多重继承（Multiple Inheritance）：

多重继承示意图：

多重继承示意图

如果在多重继承中 Class A 和 Class B 存在同名数据成员，则对 Class C 而言这个同名的数据成员容易产生二义性问题。这里的二义性是指无法直接通过变量名进行读取，需要通过域 (::) 成员运算符进行区分。例如：

//基类A
class A
{
public:
    A() :m_data(1), m_a(1)
    {
    }
    ~A(){}

public:
    int m_data;      //同名变量，类型无要求
    int m_a;
};

//基类B
class B
{
public:
    B() :m_data(1), m_b(1)
    {
    }
    ~B(){}

public:
    int m_data;      //同名变量，类型无要求
    int m_b;
};

class C  : public A, public B
{

};

int _tmain(int argc,  _TCHAR* argv[])
{
    C Data;
   //Data.m_data  = 10;   //错误, 提示指向不明确

   //通过域(::)运算符才可以访问，使用不方便
    Data.A::m_data = 10.1;
    Data.B::m_data = 20;

    std::cout << Data.A::m_data << "   " << Data.B::m_data << std::endl;

    return 0;
}

分析

我们可以通过域 (::) 运算符对同名变量进行读写操作，但是不是很方便，不能直接通过.变量的形式进行操作，形如 Data.m_data。

菱形继承

在多重继承中，存在一个很特殊的继承方式，即菱形继承。比如一个类 C 通过继承类 A 和类 B，但是类 A 和类 B 又同时继承于公共基类 N：

菱形继承示意图：

菱形继承示意图

这种继承方式也存在数据的二义性，这里的二义性是由于他们间接都有相同的基类导致的。这种菱形继承除了带来二义性之外，还会浪费内存空间。

代码如下：

//公共基类
class N
{
public:
    N(int data1, int data2, int data3) :
        m_data1(data1),
        m_data2(data2),
        m_data3(data3)
    {
        std::cout << "call common constructor" << std::endl;
    }
    virtual ~N(){}

    void    display()
    {
        std::cout << m_data1 << std::endl;
    }

public :
    int     m_data1;
    int     m_data2;
    int     m_data3;
};

class A : /*virtual*/ public N
{
public:
    A() :N(11, 12, 13), m_a(1)
    {
        std::cout << "call class A constructor" << std::endl;
    }
    ~A(){}

public :
    int m_a;
};

class B :  /*virtual*/ public N
{
public:
    B() :N(21, 22, 23),m_b(2)
    {
        std::cout << "call class B constructor" << std::endl;
    }
    ~B(){}

public :
    int m_b;
};

class C : public A ,  public B
{
public:
    //负责对基类的初始化
    C() : A(), B(),
        m_c(3)
    {
        std::cout << "call class C constructor" << std::endl;
    }
    void show()
    {
        std::cout << "m_c=" << m_c << std::endl;
    }

 public :
    int m_c;
};

我们通过 VS 自带的内存分析模型工具，得到如下的内存分布模型：

内存分布模型：

内存分布模型

我们发现在类 C 中存在两份的基类 N，分别存在类 A 和类 B 中，如果数据多则严重浪费空间，也不利于维护，我们引用基类 N 中的数据还需要通过域运算符进行区分。例如：

C data;
data.A::m_data1 = 10;
data.B::m_data1 = 10;

虚基类 & 虚继承

为了解决上述菱形继承带来的问题，C++ 中引入了虚基类，其作用是在间接继承共同基类时只保留一份基类成员，虚基类的声明如下：

class A//A 基类
{ ... };

//类B是类A的公用派生类, 类A是类B的虚基类
class B : virtual public A
{  ... };

//类C是类A的公用派生类, 类A是类C的虚基类
class C : virtual public A
{  ... };

虚基类并不是在声明基类时声明的，而是在声明派生类时，指定继承方式声明的。

虚继承是声明类时的一种继承方式，在继承属性前面添加 virtual 关键字。

//此时基类N并不是虚基类，因为声明继承类D时没有指定虚继承方式
class D : public N
{
  ...
};

在内存分析模型中没有 virtual 关键字：

内存模型：

内存模型

虚基类的初始化

这里直接说明结论，对于虚基类的初始化是由最后的派生类中负责初始化。

在最后的派生类中不仅要对直接基类进行初始化，还要负责对虚基类初始化。例如：

// 类A和类B是虚继承方式
class C : public A, public B
{
public:
    //负责对直接基类的初始化 以及虚基类的初始化
    C() : A(), B(), N(31,32,33) ,
        m_c(3)
    {
        std::cout << "call class C constructor" << std::endl;
    }
    void show()
    {
        std::cout << "m_c=" << m_c << std::endl;
    }

public:
    int m_c;
};

虚基类构造次数

C++ 编译系统只执行最后的派生类对基类的构造函数调用，而忽略其他派生类对虚基类的构造函数调用。从而避免对基类数据成员重复初始化。因此，虚基类只会构造一次。

若不是普通的继承，则存在重复构造，左边普通继承，右边虚继承，看下图：

构造次数对比：

构造次数对比

有虚基类的派生类中，虚基类只有一个构造函数输出 “call common constructor”。

虚基类的内存分析

我们通过内存模型分析工具，得到最后派生类的内存模型对比图：

左图是有虚基类的派生类 C 的内存分析,右边是菱形继承的内存分析：

内存模型对比图：

内存模型对比图

我们发现虚继承的派生类 C 的内存比非虚继承的派生类 C 内存要小 8 个字节，并且虚基类在派生类中只存在一份，虚基类有 virtual 关键字标识。

因此我们在派生类中引用基类 N 的数据，不需要使用域成员运算符，因为只有一个基类对象。例如：

C data;
data.m_data1 = 10;

虚基类的完整分析代码

//公共基类
class N
{
public:
    N(int data1, int data2, int data3) :
        m_data1(data1),
        m_data2(data2),
        m_data3(data3)
    {
        std::cout << "call common constructor" << std::endl;
    }
    virtual ~N(){}

    void    display()
    {
        std::cout << m_data1 << std::endl;
    }

public:
    int     m_data1;
    int     m_data2;
    int     m_data3;
};

//虚继承方式
class A : virtual public N
{
public:
    A() :N(11, 12, 13), m_a(1)
    {
        std::cout << "call class A constructor" << std::endl;
    }
    ~A(){}

public:
    int m_a;
};

//虚继承方式
class B :  virtual public N
{
public:
    B() :N(21, 22, 23), m_b(2)
    {
        std::cout << "call class B constructor" << std::endl;
    }
    ~B(){}

public:
    int m_b;
};

  // 类A和类B是虚继承方式
class C : public A, public B
{
public:
    //负责对直接基类的初始化 以及虚基类的初始化
    C() : A(), B(), N(31,32,33),
        m_c(3)
    {
        std::cout << "call class C constructor" << std::endl;
    }
    void show()
    {
        std::cout << "m_c=" << m_c << std::endl;
    }

public:
    int m_c;
};

//此时基类N不是虚基类
class D : public N
{
public:
    //负责对基类的初始化
    D() :N(41, 42, 43),
        m_d(4)
    {
        std::cout << "call class D constructor" << std::endl;
    }
    void show()
    {
        std::cout << "m_d=" << m_d << std::endl;
    }

public:
    int m_d;
};

int _tmain(int argc,  _TCHAR* argv[])
{
    C data;
    //直接使用基类数据
    data.m_data1 = 10;

    return 0;
}
t m_c;
};

//此时基类N不是虚基类
class D : public N
{
public:
    //负责对基类的初始化
    D() :N(41, 42, 43),
        m_d(4)
    {
        std::cout << "call class D constructor" << std::endl;
    }
    void show()
    {
        std::cout << "m_d=" << m_d << std::endl;
    }

public:
    int m_d;
};

int _tmain(int argc,  _TCHAR* argv[])
{
    C data;
    //直接使用基类数据
    data.m_data1 = 10;

    return 0;
}
虚表指针在C++类的继承/多态与重载中的基本逻辑
新兴IT民工的专栏
12-09 985
虚表指针在重载，继承和多态中的基本逻辑
C++虚继承和虚基类
居老师的博客
03-24 290
多继承（Multiple Inheritance）是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。尽管概念上非常简单，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突就是不可回避的一个。 多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如典型的是菱形继承，如下图所示： 图1：菱形继承 类 A 派生出类 B 和类 C，类 D 继承自类 B 和类 C，这个时候类 A 中的成员变量和成员函.
一文读懂C++虚继承的内存模型
彼方的博客
06-30 1万+
一文读懂C++虚继承的内存模型1、前言2、多继承存在的问题3、虚继承简介4、虚继承在标准库中的使用5、虚继承下派生类的内存布局解析6、总结 1、前言 C++虚继承的内存模型是一个经典的问题，其具体实现依赖于编译器，可能会出现较大差异，但原理和最终的目的是大体相同的。本文将对g++中虚继承的内存模型进行详细解析。 2、多继承存在的问题 C++的多继承是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。从概念上来讲这是非常简单的，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突
C++虚继承原理与类布局分析
ThousandPine的博客
07-14 874
在开始深入了解虚继承之前，我们先要明白C++引入虚继承的目的。C++有别于其他OOP语言最明显的特性就是类的多继承，而结构则是多继承中最令人头疼的情况。我们都知道，当派生类继承基类时，派生类内部会保存一份基类数据的副本。在D->BCBC->A的菱形继承结构中，BC各自存有一份A成员变量的副本，这导致D继承BC后同时保存了两份A成员变量，这就导致了空间浪费和语法二义性的问题。所以C++引入了虚继承，用于解决菱形继承导致的数据冗余。
C++类的继承（虚继承）
沃和莱特的博客
12-02 1475
C++中类的继承--虚继承和析构函数
C++之虚函数与虚继承详解
居老师的博客
03-24 1826
虚继承和虚函数是完全无相关的两个概念。 虚继承是解决C++多重继承问题的一种手段，从不同途径继承来的同一基类，会在子类中存在多份拷贝。这将存在两个问题： 其一，浪费存储空间； 第二，存在二义性问题，通常可以将派生类对象的地址赋值给基类对象，实现的具体方式是，将基类指针指向继承类（继承类有基类的拷贝）中的基类对象的地址，但是多重继承可能存在一个基类的多份拷贝，这就出现了二义性。 虚继承可以解决多种继承前面提到的两个问题： 虚继承底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现，每个虚继
C++.继承——虚继承
xiaoyu1381的博客
10-18 2229
C++.继承——虚继承
C++的多继承和虚继承
m0_51415606的博客
12-26 1310
C++支持多继承，即一个派生类可以有多个基类。很多时候，单继承就可以满足开发需求，但在特定的情况下就不行。比如有两个类A和B，现在要有一个类C，它同时具有A和B的属性和行为，这种情况下单继承就不能满足要求。从形态学上来讲，鸭嘴兽应该属于鸟类，原因是鸭嘴兽具有扁平的、像鸭子一样的嘴巴，而且是角质的，不像哺乳动物那种肉质的口唇，关键是鸭嘴兽通过下蛋来繁殖后代，这明显是鸟类的特征。然而，鸭嘴兽也靠乳汁来哺育幼仔，浑身密布着浓褐色的短兽毛，这又是哺乳动物的重要特征。所以鸭嘴兽既是鸟类，又是哺乳动物。
C++菱形继承问题和虚继承分析
热门推荐
Keep Moving~
01-10 2万+
多重继承 在面向对象中，常常存在这样的事情，一个派生类有两个或两个以上的基类。例如 菱形继承 二义性 虚基类 虚基类的作用是 在间接继承共同基类时只保留一份基类成员。 class A//A 基类 { ... }; //类B是类A的功用派生类, 类A是类B的虚基类 class B : virtual public A { ... }; //类C是类A的功用派生类, 类A是类C的虚基类 clas...
C++中虚函数与虚继承区别浅析笔记
qq_40324647的博客
06-23 1171
虚继承和虚函数是完全无相关的两个概念。 虚函数:是在函数声明/定义时，必须加上virtual关键字。作用就是让其派生类能够覆盖此函数，从而实现多态(运行时多态)。 补充：编译时多态性:通过重载函数和运算符重载实现。运行时多态性:通过虚函数和继承实现。 还有一点就是在派生类中，继承基类同名的虚函数后，不管派生类中显示写不写virtual，此函数依然是虚函数。 还有一种纯虚函数。纯虚函数在基类...
C++ 虚继承对基类构造函数调用顺序的影响
01-20
继承作为面向对象编程的一种基本特征，其使用频率... 　假设derived 虚继承自base类，那么derivd与base是一种“has a”的关系，即derived类有一个指向base类的vptr。（貌似有些牵强！某些编译器确实如此） 　因此虚
深度解读《深度探索C++对象模型》之C++虚继承的实现分析和效率评测（一）
iShare_Carlos的博客
05-13 1067
C++对象在经过类的封装后，存取对象中的数据成员的效率是否相比C语言的结构体访问效率要低下？本篇将从C++编译器的角度出发，来分析虚继承的实现，以及它们的存取效率如何？
＜C++＞冒泡排序、归并排序详解 时间复杂度 与应用
weixin_51710308的博客
05-05 524
简单但效率低，适合教学或小数据。
C/C++ 路由跟踪小程序实现
liulilittle的博客
05-08 87
复制代码到新建 traceroute.c 文件之中。
基于QT(C++)实现（图形界面）校园导览系统
神仙别闹的自留地
05-07 841
本校园导览系统基本实现了校园内的导航，支持两个校区的导览，教学楼、图书馆、宿舍、体育馆等近50个建筑，360个顶点，近700条边，并可以查询到校园内各种建筑物及服务设施的相关信息。在导航时，支持最短距离、最短时间、途径最短距离及交通工具的最短时间等四个策略，通过图形化界面实现了模拟导航，在导航时用户可以实时查询周边建筑信息，并可设置当前模拟导航的时间速率。本系统可以记录当前运行情况的日志文件，如学生状态变化和键入信息。
VUE3报错 ReferenceError: Cannot access ‘openInit‘ before initialization
dy1717的博客
05-05 376
vue3 ReferenceError: Cannot access xxx before initialization问题报错处理
C++进阶学习：STL常用容器--stack容器
最新发布
Miki Makimura 的博客
05-08 200
stack 是一种先进后出的数据结构 只有一个出口不允许有遍历行为可以判断是否为空可以返回元素个数。
【C++】C++中的类型转换
睿的博客
05-07 862
在平常的学习中，类型的转换其实是不断在出现的，那么C++11相比于C语言的类型转换又有了哪些不同呢？这篇文章就来教会你C++里面的类型转换更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！每日一题C语言学习算法智力题初阶数据结构Linux学习C++学习更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！
C++日志系统实现(二)
A_zyx0808的博客
05-04 865
使用缓冲池、线程池实现异步日志系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值