额滴笔记

Appearance

1. 多继承 ​

1.1 多继承的定义 ​

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

格式：

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

示例：二姓家奴吕布 ​

cpp
#include<iostream>
using namespace std;

class Dingyuan
{
protected:
    void fun_dy()
    {
        cout << "丁原" << endl;
    }
};

class Dongzhuo
{
protected:
    void fun_dz()
    {
        cout << "董卓" << endl;
    }
};

class Wangyun
{
protected:
    void fun_wy()
    {
        cout << "王允" << endl;
    }
};

class Lvbu : public Dingyuan, public Dongzhuo, public Wangyun
{
public:
    void introduce()
    {
        cout << "我的义父有: " << endl;
        fun_dy();
        fun_dz();
        fun_wy();
    }
};

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

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

cpp
#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 Dingyuan, public Wangyun, public Dongzhuo
{
};

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

1.2 多继承向上造型（了解） ​

在多重继承的场景中，向上造型（即把派生类指针或引用转换为基类指针或引用）时，编译器会考虑每个基类子对象在派生类内存布局中的实际位置。由于派生类可能从多个基类继承，并且每个基类在内存中的位置都可能不同，因此编译器需要执行适当的偏移计算来确保指针的类型与其所指向的目标对象类型一致。

这种偏移计算是编译器在编译时自动进行的，程序员通常不需要（也不应该）手动干预这个过程。编译器会根据类定义中的继承关系和每个基类的内存需求来计算这些偏移量。

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

1.3 名字冲突问题 ​

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

cpp
#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;
}

解决方案 ​

解决名字冲突的一般做法就是显式的使用作用域限定操作符，指明所访问的成员属于哪个基类。

cpp
class Lvbu : public Dingyuan, public Dongzhuo, public Wangyun
{
public:
    void introduce()
    {
        cout << "我的义父有: " << endl;
        fun_dy();
        fun_dz();
        fun_wy();
        // aim(); // error 基类中存在多个aim()同名函数，存在歧义问题
        Dingyuan::aim();
        Dongzhuo::aim();
        Wangyun::aim();
    }
};

1.4 钻石继承（菱形继承） ​

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

B     C
 \   /
   D

即D继承B和C。

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

在C++中，钻石继承（diamond inheritance）指的是一种多重继承情况，其中一个类继承有两个或多个类，而这些父类又都继承自同一个基类。由于继承关系形成了一个类似于钻石的形状，因此得名钻石继承。

    A
   / \
  B   C
   \ /
    D

即D继承B和C，而B和C有同时继承A。

钻石继承存在的问题 ​

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

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
    
    cout << "Value through Derived1: " << fd.Derived1::value << endl;
    cout << "Value through Derived2: " << fd.Derived2::value << endl;
    
    return 0;
}

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

1.5 虚继承 ​

格式：

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

示例 ​

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

cpp
#include<iostream>
using namespace std;

class Base
{
public:
    int value;
    Base() : value(0) {}
};

class Derived1 : virtual public Base
{
    // Derived1 通过虚继承继承自 Base
};

class Derived2 : virtual public Base
{
    // Derived2 也通过虚继承继承自 Base
};

class FinalDerived : public Derived1, public Derived2
{
    // FinalDerived 继承自 Derived1 和 Derived2，它们都虚继承了 Base
};

int main()
{
    FinalDerived fd;
    fd.value = 10; // 访问共享的 Base 子对象中的 value 成员
    
    // 由于虚继承，FinalDerived 中只有一个 Base 子对象，因此不会有数据重复
    // 并且不会有访问 Base 成员时的二义性
    return 0;
}

虚继承原理 ​

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

  1. 虚基类指针：在使用虚继承的派生类中，编译器会自动加入一个指向虚基类的指针。这个指针占用子类的一部分空间，它指向虚基类表。通过这个指针，子类可以访问其虚基类的成员。
  2. 虚基类表：虚基类表不占用子类空间，它记录了虚基类与子类的偏移量。通过这个偏移量，子类可以找到它继承的虚基类成员的具体位置。

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

cpp
#include<iostream>
using namespace std;

class A {
public:
    A(int data) :m_data(data) {
        cout << "公共基类A" << ",size = " << sizeof(A) << endl;
    }
protected:
    int m_data;
};

class B : virtual public A { // 虚继承
public:
    B(int data) :A(data) {
        cout << "中间B类" << ",size = " << sizeof(B) << endl;
    }
    void set(int data) {
        m_data = data;
    }
};

class C : virtual public A { // 虚继承
public:
    C(int data) :A(data) {
        cout << "中间C类" << ",size = " << sizeof(C) << endl;
    }
    int get(void) {
        return m_data;
    }
};

class D : public B, public C {
public:
    // 虚继承时，D类构造函数负责构造A基类子对象
    D(int data) : B(data), C(data), A(data) {
        cout << "汇聚D类" << ",size = " << sizeof(D) << endl;
    }
};

int main() {
    D d(100);
    cout << d.get() << endl; //100
    d.set(200);
    cout << d.get() << endl; //200
    return 0;
}

1.6 构造函数和虚继承 ​

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

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

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

所以，C++规定，在虚继承体系中，虚基类的成员由最底层的派生类(D)去初始化。

也就是说，当含有虚基类的派生类D实例化对象的时候，先由D调用虚基类的构造函数，再按照直接基类在派生类列表中出现的顺序，依次调用直接基类的构造函数。

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

cpp
#include <iostream>
using namespace std;

class A
{
public:
    A(int data) : m_data(data)
    { // 带有参数的构造函数
        cout << "虚基类A被初始化, data = " << data << endl;
    }
    // 默认构造函数
    A() : m_data(0)
    { // 默认构造函数
        cout << "虚基类的默认构造函数被调用" << 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;
}

知识如风，常伴吾身

Copyright © 2023-2025 Kgumo