跳转至

多继承与虚基类

多继承允许一个派生类同时从多个基类继承，这提供了更强大的代码复用能力，但也带来了二义性和冗余继承等复杂问题。虚基类正是为解决这些问题而设计的机制。

多继承带来的问题

多继承（Multiple Inheritance） 是指一个派生类可以同时从多个基类继承。这在现实世界中有自然对应的例子：

  • 水上飞机：同时继承自"飞机"和"船只"的特征。
  • 智能家居设备：同时继承自"电器"和"网络设备"的特征。
  • 兼职人员：同时具有"教师"和"研究员"的身份。

多继承虽然功能强大，但也引入了两个核心问题。这些问题如果处理不当，会导致代码难以理解和维护。

多继承的两大挑战

  1. 二义性问题：从不同基类继承了同名成员时，编译器无法确定使用哪一个。
  2. 冗余继承问题：多个基类共享同一个间接基类时，会导致该间接基类的成员被重复继承（菱形继承）。

二义性问题

什么是二义性

当派生类从多个基类继承了同名成员（数据成员或成员函数），且派生类本身没有定义同名成员来覆盖它们时，通过派生类对象访问该成员就会产生二义性（Ambiguity）——编译器不知道应该使用哪个基类的版本。

二义性问题示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
using namespace std;

class Base1 {
public:
    int value = 10;
    void show() {
        cout << "Base1::show()" << endl;
    }
};

class Base2 {
public:
    int value = 20;
    void show() {
        cout << "Base2::show()" << endl;
    }
};

// 派生类同时继承 Base1 和 Base2
class Derived : public Base1, public Base2 {
    // 没有新增同名成员来覆盖
};

int main() {
    Derived d;

    // d.value = 30;   // ❌ 二义性错误！是 Base1::value 还是 Base2::value？
    // d.show();       // ❌ 二义性错误！是 Base1::show() 还是 Base2::show()？

    // 正确方式：使用基类名限定
    d.Base1::value = 30;
    d.Base2::value = 40;

    d.Base1::show();   // Base1::show()
    d.Base2::show();   // Base2::show()

    return 0;
}

使用基类名限定解决二义性

解决二义性的最直接方式是使用作用域限定符 :: 明确指定要访问的基类版本。

基类名限定的两种方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
int main() {
    Derived d;

    // 方式一：通过对象直接限定
    d.Base1::value = 10;
    d.Base2::show();

    // 方式二：通过指针限定
    Derived* p = &d;
    p->Base1::value = 20;
    p->Base2::show();

    return 0;
}

同名隐藏解决二义性

另一种解决二义性的方式是在派生类中定义同名成员，实现同名隐藏（Name Hiding），然后内部根据需要调用特定的基类版本。

同名隐藏方案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
using namespace std;

class Base1 {
public:
    void show() { cout << "Base1::show()" << endl; }
};

class Base2 {
public:
    void show() { cout << "Base2::show()" << endl; }
};

class Derived : public Base1, public Base2 {
public:
    // 在派生类中定义同名成员，隐藏基类的 show()
    void show() { cout << "Derived::show()" << endl; }

    // 也可以提供分别访问基类版本的接口
    void showBase1() { Base1::show(); }
    void showBase2() { Base2::show(); }
};

int main() {
    Derived d;

    d.show();          // Derived::show()（无二义性）
    d.showBase1();     // Base1::show()
    d.showBase2();     // Base2::show()

    // 仍然可以通过基类名限定访问
    d.Base1::show();   // Base1::show()
    d.Base2::show();   // Base2::show()

    return 0;
}

冗余继承问题（菱形继承）

什么是冗余继承

当多个基类共享同一个间接基类时，派生类中会包含多份间接基类的成员副本，这就是冗余继承（Redundant Inheritance），通常表现为菱形继承（Diamond Inheritance）。

菱形继承结构

          Base0（共同基类）
         /       \
    Base1        Base2
         \       /
          Derived

在这个结构中，Derived 从 Base1 和 Base2 继承，而 Base1 和 Base2 都继承自 Base0。这导致 Derived 中包含了两份 Base0 的成员副本。

菱形继承的问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <iostream>
using namespace std;

class Base0 {
public:
    int var0 = 0;
    void fun0() { cout << "Base0::fun0()" << endl; }
};

class Base1 : public Base0 {
public:
    int var1 = 10;
};

class Base2 : public Base0 {
public:
    int var2 = 20;
};

class Derived : public Base1, public Base2 {
public:
    int var = 30;
};

int main() {
    Derived d;

    // ❌ 二义性：Derived 中有两份 Base0::var0 的副本
    // d.var0 = 5;

    // ✓ 使用基类名限定，明确访问哪一份副本
    d.Base1::var0 = 1;   // 访问 Base1 继承来的 Base0 副本
    d.Base2::var0 = 2;   // 访问 Base2 继承来的 Base0 副本

    cout << "Base1::var0 = " << d.Base1::var0 << endl;   // 1
    cout << "Base2::var0 = " << d.Base2::var0 << endl;   // 2

    // 问题：这两份副本是独立的！修改一个不影响另一个

    return 0;
}

菱形继承的三个问题

  1. 二义性：访问共同基类的成员时，编译器不知道使用哪一份副本。
  2. 数据冗余：派生类中包含多份共同基类的成员副本，浪费内存。
  3. 数据不一致：多份副本各自独立，修改其中一份不会影响另一份，可能导致数据不一致。

Derived 对象的内存布局

菱形继承的内存布局（无虚基类）
┌─────────────────────────────────────┐
│               Derived               │
├─────────────────────────────────────┤
│  Base1 部分                          │
│  ├── Base0 部分 (第一份)              │
│  │   ├── var0                       │
│  │   └── ...                        │
│  ├── var1                           │
├─────────────────────────────────────┤
│  Base2 部分                          │
│  ├── Base0 部分 (第二份)              │
│  │   ├── var0                       │
│  │   └── ...                        │
│  ├── var2                           │
├─────────────────────────────────────┤
│  var (派生类新增)                     │
└─────────────────────────────────────┘

共存在两份 Base0 的成员副本！

虚基类

虚基类的定义

虚基类（Virtual Base Class） 通过 virtual 关键字声明继承方式，确保在多层继承中共同基类只被继承一次，从而解决数据冗余和二义性问题。

虚基类的声明语法

class 派生类名 : virtual 继承方式 基类名 {
    // ...
};

// 或者
class 派生类名 : 继承方式 virtual 基类名 {
    // ...
};

使用虚基类解决菱形继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <iostream>
using namespace std;

class Base0 {
public:
    int var0 = 0;
    void fun0() { cout << "Base0::fun0()" << endl; }
};

// Base1 虚继承 Base0
class Base1 : virtual public Base0 {
public:
    int var1 = 10;
};

// Base2 虚继承 Base0
class Base2 : virtual public Base0 {
public:
    int var2 = 20;
};

// Derived 继承 Base1 和 Base2
class Derived : public Base1, public Base2 {
public:
    int var = 30;
};

int main() {
    Derived d;

    // ✓ 无二义性！Derived 中只有一份 Base0 的副本
    d.var0 = 5;
    d.fun0();

    cout << "var0 = " << d.var0 << endl;   // 5

    // ✓ 通过任意路径访问都是同一份副本
    d.Base1::var0 = 10;
    cout << "d.Base2::var0 = " << d.Base2::var0 << endl;   // 10（同一份！）

    return 0;
}

虚基类解决的问题

虚基类的核心价值

问题 普通继承 虚继承
共同基类副本数量 多份 一份
成员访问二义性 存在 消除
数据一致性 不一致 一致
内存占用 较大 较小

虚基类对象的内存布局

菱形继承的内存布局（使用虚基类）
┌─────────────────────────────────────┐
│               Derived               │
├─────────────────────────────────────┤
│  Base1 部分                          │
│  ├── var1                           │
│  ├── (虚基类指针 → Base0)             │
├─────────────────────────────────────┤
│  Base2 部分                          │
│  ├── var2                           │
│  ├── (虚基类指针 → Base0)             │
├─────────────────────────────────────┤
│  var (派生类新增)                     │
├─────────────────────────────────────┤
│  Base0 部分 (唯一的一份)              │
│  ├── var0                           │
│  └── ...                            │
└─────────────────────────────────────┘

只有一份 Base0 的成员副本！

虚基类的构造函数

虚基类构造函数的特殊性

虚基类的初始化规则与普通基类不同：由最远派生类的构造函数直接调用虚基类的构造函数，中间层的基类对虚基类构造函数的调用会被忽略。

虚基类构造规则

  • 虚基类的成员由最远派生类的构造函数通过调用虚基类的构造函数进行初始化。
  • 在整个继承结构中，直接或间接继承虚基类的所有派生类，都必须在构造函数的成员初始化表中为虚基类的构造函数列出参数。
  • 只有最远派生类的构造函数会真正调用虚基类的构造函数，其他类对虚基类构造函数的调用被忽略。

虚基类构造函数的调用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>
using namespace std;

class Base0 {
public:
    Base0(int var) : var0(var) {
        cout << "Base0 constructor: var0 = " << var0 << endl;
    }
    int var0;
};

class Base1 : virtual public Base0 {
public:
    // 虽然 Base1 的初始化列表中调用了 Base0，
    // 但如果 Derived 是最远派生类，这个调用会被忽略
    Base1(int v) : Base0(v) {
        cout << "Base1 constructor" << endl;
    }
    int var1;
};

class Base2 : virtual public Base0 {
public:
    // 同 Base1，这个调用也可能被忽略
    Base2(int v) : Base0(v) {
        cout << "Base2 constructor" << endl;
    }
    int var2;
};

class Derived : public Base1, public Base2 {
public:
    // 最远派生类 Derived 负责初始化虚基类 Base0
    Derived(int v0, int v1, int v2)
        : Base0(v0),      // ✓ 这个调用真正执行
          Base1(v1),      // 这个调用被忽略（不会再次初始化 Base0）
          Base2(v2) {     // 这个调用被忽略（不会再次初始化 Base0）
        cout << "Derived constructor" << endl;
    }
};

int main() {
    Derived d(100, 10, 20);
    cout << "var0 = " << d.var0 << endl;   // 100（由 Derived 的 Base0 调用初始化）
    return 0;
}

运行结果：

Base0 constructor: var0 = 100   ← 只调用了一次！
Base1 constructor
Base2 constructor
Derived constructor
var0 = 100

重要对比

场景 谁调用虚基类构造函数 说明
创建派生类对象（非最远派生类） 该类自己的构造函数 正常调用
创建最远派生类对象（如 Derived） 最远派生类的构造函数 中间层的调用被忽略
创建普通基类对象 该基类的构造函数 正常调用

虚基类构造函数的完整示例

虚基类构造函数的调用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <iostream>
using namespace std;

// 共同基类
class Person {
private:
    string name;
    int age;
public:
    Person(const string& n, int a) : name(n), age(a) {
        cout << "Person constructor: " << name << ", " << age << endl;
    }

    void showPerson() const {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

// 虚继承 Person
class Teacher : virtual public Person {
private:
    string department;
public:
    Teacher(const string& n, int a, const string& dept)
        : Person(n, a), department(dept) {
        cout << "Teacher constructor: " << department << endl;
    }

    void teach() const {
        cout << "Teaching in " << department << endl;
    }
};

// 虚继承 Person
class Student : virtual public Person {
private:
    string major;
public:
    Student(const string& n, int a, const string& m)
        : Person(n, a), major(m) {
        cout << "Student constructor: " << major << endl;
    }

    void study() const {
        cout << "Studying " << major << endl;
    }
};

// 多重继承 Teacher 和 Student
class TeachingAssistant : public Teacher, public Student {
private:
    string course;
public:
    // 最远派生类直接初始化虚基类 Person
    TeachingAssistant(const string& n, int a,
                    const string& dept, const string& m, const string& c)
        : Person(n, a),         // 真正初始化虚基类
        Teacher(n, a, dept),  // 对 Person 的调用被忽略
        Student(n, a, m),     // 对 Person 的调用被忽略
        course(c) {
        cout << "TeachingAssistant constructor: " << course << endl;
    }

    void show() const {
        showPerson();
        cout << "Department: " << department << endl;
        cout << "Major: " << major << endl;
        cout << "Course: " << course << endl;
    }
};

int main() {
    TeachingAssistant ta("张三", 25, "计算机系", "软件工程", "C++程序设计");
    ta.show();

    // 验证只有一份 Person 副本
    ta.Teacher::showPerson();   // 同一份数据
    ta.Student::showPerson();   // 同一份数据

    return 0;
}

虚基类 vs 普通继承

虚基类与普通继承的对比

特性 普通继承 虚继承
共同基类副本 多份 一份
成员访问二义性 存在，需限定 自动消除
数据一致性 不一致 一致
内存开销 较小 稍大（需要额外的指针）
构造函数调用 逐层调用 最远派生类直接调用
使用场景 无菱形继承的常规场景 存在菱形继承时
性能 略快 略慢（需间接访问）

使用建议

  1. 在菱形继承的第一层使用虚继承：当 Base1 和 Base2 继承自 Base0 时，在 Base1 和 Base2 的定义中使用虚继承。
  2. 虚继承应该在继承树的上层就做好决策：如果在中间层才添加 virtual，可能影响已有的代码结构。
  3. 虚基类构造函数的参数要在最远派生类中传递。
  4. 如果确定不会出现菱形继承，使用普通继承即可，避免不必要的虚继承开销。

经典设计准则

在 C++ 中，优先使用组合而不是多重继承。如果确实需要使用多重继承，优先考虑使用虚继承来解决菱形继承问题，但要意识到虚继承带来的额外复杂性和性能开销。

小结

  1. 多继承的二义性问题：
    • 从多个基类继承同名成员时产生。
    • 解决方式：使用基类名限定（d.Base1::show()）或在派生类中同名隐藏。
  2. 菱形继承与冗余问题：
    • 多个基类共享同一个间接基类时，派生类包含多份共同基类的副本。
    • 导致二义性、数据冗余和数据不一致。
  3. 虚基类（Virtual Base Class）：
    • 在继承声明中使用 virtual 关键字：class Base1 : virtual public Base0。
    • 确保共同基类在派生类中只有一份副本。
    • 解决了二义性、数据冗余和不一致问题。
  4. 虚基类的构造函数：
    • 由最远派生类的构造函数直接调用虚基类的构造函数。
    • 中间层基类对虚基类构造函数的调用会被忽略。
  5. 使用建议：
    • 在菱形继承的第一层声明虚继承。
    • 优先考虑组合而非多重继承。
    • 如果必须使用多重继承，评估是否需要虚基类。