c++的特性之一 多继承

于 2025-04-22 06:45:25 发布
阅读量704 收藏 14
点赞数 32
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_84775671/article/details/147405915
版权

多继承

1 多继承的定义

多继承（Multiple Inheritance）是面向对象编程中的一个概念，它允许一个类继承自多个父类。一个子类可以获取多个父类的属性和方法，从而组合不同父类的功能来创建更复杂的类

格式：

class 派生类名称:继承方式1 基类1,继承方式2 基类2
 {
派生类自己新增的特性
};

三姓家奴吕布

#include <iostream>
using namespace std;
class DingYuan
{
public:
    DingYuan(const string &name = "王允") :m_name(name){}
protected:
    void who_dy()
    {
        cout << m_name <<endl;
    }
​
    string m_name;
};
class DongZhuo
{
public:
    DongZhuo(const string &name = "董卓"):m_name(name) {}
protected:
    void who_dz()
    {
        cout << m_name <<endl;
    }
private:
    string m_name;
};
class WangYun
{
public:
    WangYun(const string &name = "丁原"):m_name(name) {}
protected:
    void who_wy()
    {
        cout << m_name <<endl;
    }
private:
    string m_name;
};
class lvBu:public  DingYuan, public DongZhuo, public  WangYun
{
public:
    void intrdouce()
    {
         cout << "我的义父有：" << endl;
         who_dy();
         who_dz();
         who_wy();
         cout << DingYuan::m_name << endl;//访问基类成员变量
    }
  
};
​
int main()
{
    lvBu l;
    l.intrdouce();
   
    return 0;
}

  • 普通的多重继承下,在构造派生类的时候,会先调用基类的构造函数,在有多个基类的时候,是按照继 承声明顺序调用的

#include<iostream>
 using namespace std;
 class Dingyuan
 {
 protected:
 Dingyuan()
 {
 cout << "丁原" << endl;
 }
 };
 class Dongzhuo
 {
 protected:
 Dongzhuo()
 {
 cout << "董卓" << endl;
 }
 };
 class Wangyun
 {
 protected:
 Wangyun()
 {
 cout << "王允" << endl;
 }
 };
 ;
class Lvbu :  public Wangyun, public Dongzhuo, public Dingyuan{};
 int main()
 {
 Lvbu l;
 return 0;
 }

输出的顺序是王允董卓丁原，而不是丁原董卓王允，可见是按继承声明顺序调用的

2 多继承向上造型（了解）

  • 多重继承的场景中，向上造型（即把派生类指针或引用转换为基类指针或引用）时，编译器会考虑每 个基类子对象在派生类内存布局中的实际位置。

  • 由于派生类可能从多个基类继承，并且每个基类在内存 中的位置都可能不同，因此编译器需要执行适当的偏移计算来确保指针的类型与其所指向的目标对象类 型一致.

  • 由于派生类可能从多个基类继承，并且每个基类在内存 中的位置都可能不同，因此编译器需要执行适当的偏移计算来确保指针的类型与其所指向的目标对象类 型一致

int main()
 {
 Lvbu *l1;
 Dingyuan *dy = l1;//向上造型
Lvbu l2;
 Dongzhuo&dz = l2;//向上造型
Wangyun* wy = &l2;//向上造型
return 0;
 }

3 名字冲突问题

在多继承的情况下,名字的查找过程是在所有直接基类中同时进行的.一个子类的多个基类如果存在相同名 字的成员,当通过子类访问这些成员时,编译器会报歧义错误（名字冲突）

#include<iostream>
 using namespace std;
 class Dingyuan
 {
 protected:    
     void fun_dy()
    {
     cout << "丁原" << endl;
    }
    void aim()
    {
    cout << "统一西凉" << endl;
    }
 };
 class Dongzhuo
 {
 protected:
    void fun_dz()
    {
         cout << "董卓" << endl;
    }
    void aim()
    {

        cout << "把持朝纲" << endl;
    }
 };
 class Wangyun
 {
 protected:
    void fun_wy()
    {
        cout << "王允" << endl;
     }
    void aim()
    {
        cout << "拯救大汉" << endl;
    }
 };
 class Lvbu : public Dingyuan, public Dongzhuo, public Wangyun
    {
 public:
    void introduce()
    {
        cout << "我的义父有：" << endl;
        fun_dy();
        fun_dz();
        fun_wy();
        // aim(); //error 基类中存在多个aim()同名函数，有歧义

    }
 };
 int main()
 {
    Lvbu l;
    l.introduce();
    return 0;
 }

显示声明就行，显式的使用作用域限定操作符,指明所访问的成员属于哪个基类

#include<iostream>
 using namespace std;
 class Dingyuan
 {
 protected:    
     void fun_dy()
    {
     cout << "丁原" << endl;
    }
    void aim()
    {
    cout << "统一西凉" << endl;
    }
 };
 class Dongzhuo
 {
 protected:
    void fun_dz()
    {
         cout << "董卓" << endl;
    }
    void aim()
    {

        cout << "把持朝纲" << endl;
    }
 };
 class Wangyun
 {
 protected:
    void fun_wy()
    {
        cout << "王允" << endl;
     }
    void aim()
    {
        cout << "拯救大汉" << endl;
    }
 };
 class Lvbu : public Dingyuan, public Dongzhuo, public Wangyun
    {
 public:
    void introduce()
    {
        cout << "我的义父有：" << endl;
        fun_dy();
        fun_dz();
        fun_wy();
        // aim(); //error 基类中存在多个aim()同名函数，有歧义
        Dingyuan::aim();
        Wangyun::aim();
        Dongzhuo::aim();
    }
 };
 int main()
 {
    Lvbu l;
    l.introduce();
    return 0;
 }

4 钻石继承（菱形继承）

c++支持多继承，即一个子类可以同时继承多个父类

 B   C
 \ /
  D
即D继承B和C

而当B和C同时继承自同一个类时，此时便构成了钻石继承。

  A
 / \
 B   C
 \ /
  D
即D继承B和C,而B和C有同时继承A

在C++中，钻石继承（diamond inheritance）指的是一种多重继承情况，,指的是一个类继承自个或多个 类，而这些父类又都继承自同一个基类，继承关系就像是这个钻石一样，所以叫钻石继承

  A
 / \
 B   C
 \ /
  D
即D继承B和C,而B和C有同时继承A

钻石继承存在一些问题

数据成员的二义性：如果基类有一个数据成员，那么在最终的派生类中，这个数据成员会有多个潜 在的访问路径。这会导致编译错误，因为编译器不知道应该使用哪个路径

 #include <iostream>  
class Base 
{
 public:
    int value;
 };
 class Derived1 : public Base 
{
 };
 class Derived2 : public Base 
{
 };
 class FinalDerived : public Derived1, public Derived2 
{
    // FinalDerived通过Derived1和Derived2两个路径继承了Base  
};
 int main() 
{
    FinalDerived fd;
	// 问题：编译器不知道应该通过Derived1还是Derived2来访问Base中的value  
    // 下面的代码会导致编译错误，因为存在二义性  
    // fd.value = 10; // 错误：对'value'的引用是二义的  
    // 为了解决二义性，需要显式地指定通过哪个路径来访问value  
    fd.Derived1::value = 10; // 通过Derived1路径访问Base中的value  
    fd.Derived2::value = 20; // 通过Derived2路径访问Base中的value  
    std::cout << "Value through Derived1: " << fd.Derived1::value << std::endl;
    std::cout << "Value through Derived2: " << fd.Derived2::value << std::endl;
    return 0;
 }

  • 由于最终派生类通过多条路径继承了同一个基类，因此基类的数据成员在最终派生类中会有多个拷 贝。这不仅增加了内存使用，还可能导致数据不一致的问题。

那么怎么办呢，那么就引入虚继承了

5 虚继承

格式：

//派生类承诺可以和其他类共享基类
class 派生类名称:virtual 继承方式 基类名称
{
    ...
 }

示例 在这个例子中，Derived1 和 Derived2 都虚继承了 Base 类。因此，当 FinalDerived 类继承自 Derived1 和 Derived2 时，它只包含一个 Base 类的子对象。这意味着 FinalDerived 类中的 value 成员是唯一的，不存在多个拷贝。

#include <iostream>  
class Base 
{
 public:
    int value;
 };
 class Derived1 :virtual public Base 
{
 };
 class Derived2 : virtual public Base 
{
 };
 class FinalDerived : virtual public Derived1, virtual  public Derived2 
{
    // FinalDerived通过Derived1和Derived2两个路径继承了Base  
};
 int main() 
{
    FinalDerived fd;
    fd.value = 10;
    std::cout << "Derived1 :: value" << fd.Derived1::value << std:: endl;
    std::cout << "Derived2 :: value" << fd.Derived1::value << std:: endl;
    std::cout << &fd.Derived1::value << std:: endl;
    std::cout << &fd.Derived2::value << std:: endl;
    return 0;
 }

这样的话确保了孙子类调用哪个父类都是一个东西，无论是值还是地址都是一样的

虚继承的原理主要依赖于两个关键组件：虚基类指针和虚基类表。

  1. 虚基类指针：在使用虚继承的派生类中，编译器会自动加入一个指向虚基类指针。这个指针占用 子类的一部分空间(8个字节)，它指向虚基类表。通过这个指针，子类可以访问和共享虚基类的成员。

  2. 虚基类表：虚基类表不占用子类空间，它记录了虚基类与子类的偏移量。通过这个偏移量，子类可 以找到它继承的虚基类成员的具体位置。

  • 偏移量就是地址与地址之间的差

  • 继承时，成员变量的存储方式如下：

    • 普通继承：子类会直接继承父类的所有成员变量，并在子类对象中分配相应的内存。每个父类的成员变量在子类对象中都会有一份独立的拷贝。

    • 虚继承：虚基类的成员变量在最派生类中只有一份拷贝。每个虚继承的子类都有一个虚基类指针（vbptr），指向一个虚基类表（vbtable）。这个表记录了虚基类与本类的偏移地址。通过这个偏移地址，可以找到虚基类成员变量的位置，如果访问到成员变量，就不会再重复存储

通过虚继承，无论基类被继承了多少次，都只有一个共享的基类子对象存在。这避免了数据冗余和访问 二义性，并确保了基类成员在派生类中的唯一性。

6 构造函数和虚继承

  • 钻石继承时候如果按照普通的规则去初始化,即每一个派生类(B,C)调用它直接基类(A)的构造函数,以初始化从基类(A)继承过来的成员。

  • 在没有虚继承时,是没有问题的(B,C都拥有独立的A)。

  • 在虚继承时,B和C是共享A这个子对象的,那么如果还交给B和C去初始化根部的基类成员就会被重复初始

    化，爷爷类构造函数初始化两次。

  • 所以,C++规定,在虚继承体系中,虚基类的成员由最底层的派生类(D)去初始化（跳过中间父类）。

    也就是说,当含有虚基类的派生类D实例化对象的时候,先由D调用虚基类的构造函数,再按照直接基类在派

    生类列表中出现的顺序,依次调用直接基类的构造函数

    • 最底层派生类的构造函数显式调用了虚基类的构造函数，那么虚基类就不需要提供无参构造函数。

    • 当最底层派生类的构造函数没有显式调用虚基类的构造函数时，编译器才会尝试调用虚基类的无参构造函数。如果此时虚基类没有无参构造函数，就会导致编译错误

  • 析构函数的调用顺序和构造函数的调用顺序相反

#include <iostream>  
using namespace std;
 class A 
{
 public:
 A(int data) : m_data(data) 
{ // 带有参数的构造函数  
cout << "虚基类A被初始化, data = " << data << endl;
 }
 // 默认构造函数  
A() : m_data(0) 
{ // 默认构造函数  
cout << "虚基类A的默认构造函数被调用" << endl;
 }
 protected:
 int m_data;
 };
 class B : virtual public A 
{ // 虚继承A  
public:
 B()
 { // 显式调用A的构造函数  
cout << "中间B类" << endl;
}
 // 如果您不想在B中控制A的初始化，可以省略对A的初始化  
};
 class C : virtual public A 
{ // 虚继承A  
public:
 C() 
{ // 显式调用A的构造函数  
cout << "中间C类" << endl;
 }
 // 如果您不想在C中控制A的初始化，可以省略对A的初始化  
};
 class D : public B, public C 
{ // D继承自B和C，B和C都虚继承A  
public:
 D(int data) : B(), C(), A(data)
 { // 在D中控制A的初始化  
// 注意：在C++中，虚基类的初始化只需要在初始化列表中出现一次  
// 这里A(data)是必需的，但B(data)和C(data)中的A(data)调用会被忽略  
cout << "最底层派生类D" << endl;
 }
 int get() 
{
 // 由于B和C都虚继承A，这里通过B或C访问A的成员都是相同的  
return B::m_data; // 或者使用C::m_data，结果是一样的  
}
 };
 int main()
 {
 D d(100); // A只会被初始化一次，且由D的构造函数控制  
cout << "D中的A的data成员值为: " << d.get() << endl;
 return 0;
 }

？!714
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值