目录
一、多继承的基本语法
二、二义性问题：两个基类有同名成员
解决方案1：用作用域运算符明确指定
解决方案2：在派生类中重写（覆盖）
三、菱形继承（钻石问题）
菱形继承带来的两个问题
查看重复成员
四、虚拟继承：解决方案
语法
效果
虚拟继承后的内存布局（简化）
五、虚拟继承的开销
六、完整例子：菱形继承对比
七、虚拟继承的构造顺序
八、三个常见错误
1. 过度使用多继承
2. 忘记虚拟继承导致重复基类
3. 向下转型时的混乱
九、这一篇的收获
一、多继承的基本语法
多继承就是一个类从多个基类派生：
cpp
class Base1 { public: void func1() { cout << "Base1::func1" << endl; } int data = 10; }; class Base2 { public: void func2() { cout << "Base2::func2" << endl; } int data = 20; }; class Derived : public Base1, public Base2 { public: void show() { func1(); // 来自 Base1 func2(); // 来自 Base2 } }; int main() { Derived d; d.func1(); // ✅ d.func2(); // ✅ }派生类继承了所有基类的成员。这看起来很方便——一个Student可以既是Person又是Athlete。
二、二义性问题：两个基类有同名成员
当两个基类有同名成员时，编译器不知道你要用哪一个：
cpp
class BaseA { public: void print() { cout << "BaseA::print" << endl; } int value = 100; }; class BaseB { public: void print() { cout << "BaseB::print" << endl; } int value = 200; }; class Derived : public BaseA, public BaseB { public: void test() { // print(); // ❌ 二义性错误：BaseA::print 还是 BaseB::print？ // cout << value; // ❌ 二义性错误：哪个value？ } };解决方案1：用作用域运算符明确指定
cpp
void test() { BaseA::print(); // ✅ 明确调用 BaseA 的版本 BaseB::print(); // ✅ 明确调用 BaseB 的版本 cout << BaseA::value; // 100 cout << BaseB::value; // 200 }解决方案2：在派生类中重写（覆盖）
cpp
class Derived : public BaseA, public BaseB { public: void print() override { // 提供自己的版本 BaseA::print(); // 可以内部调用 BaseB::print(); cout << "Derived::print" << endl; } };三、菱形继承（钻石问题）
这是多继承中最棘手的问题。先看结构：
text
Base / \ / \ Base1 Base2 \ / \ / Derived
四个类形成菱形结构。代码表示：
cpp
class Base { public: int data = 10; void func() { cout << "Base::func" << endl; } }; class Base1 : public Base { public: void func1() {} }; class Base2 : public Base { public: void func2() {} }; class Derived : public Base1, public Base2 { public: void test() { // data = 20; // ❌ 二义性：来自Base1路径还是Base2路径？ // func(); // ❌ 同样二义性 } };菱形继承带来的两个问题
1. 成员重复：Derived对象中包含两份Base的成员（一份从Base1来，一份从Base2来）。
text
Derived对象内存布局（非虚拟继承）： ┌─────────────────────┐ │ Base1部分 │ │ └── Base部分 │ ← 第一份data ├─────────────────────┤ │ Base2部分 │ │ └── Base部分 │ ← 第二份data ├─────────────────────┤ │ Derived部分 │ └─────────────────────┘
2. 访问二义性：访问data时，编译器不知道该用哪一份。
查看重复成员
cpp
class Base { public: int data = 10; }; class Base1 : public Base {}; class Base2 : public Base {}; class Derived : public Base1, public Base2 {}; int main() { Derived d; // cout << d.data; // ❌ 二义性 cout << d.Base1::data << endl; // 10 cout << d.Base2::data << endl; // 10（另一份） cout << sizeof(Derived) << endl; // 两份Base + 对齐，通常比预期大 }四、虚拟继承：解决方案
虚拟继承让派生类共享一份基类子对象，而不是复制两份。
语法
在继承时加上virtual关键字：
cpp
class Base1 : virtual public Base { // 虚拟继承 // ... }; class Base2 : virtual public Base { // 虚拟继承 // ... }; class Derived : public Base1, public Base2 { // 现在只有一份Base };效果
cpp
#include <iostream> using namespace std; class Base { public: int data = 10; void func() { cout << "Base::func" << endl; } }; class Base1 : virtual public Base { // 虚拟继承 public: void func1() {} }; class Base2 : virtual public Base { // 虚拟继承 public: void func2() {} }; class Derived : public Base1, public Base2 { public: void test() { data = 20; // ✅ 现在没有二义性了！只有一份Base func(); // ✅ 可以 } }; int main() { Derived d; d.test(); cout << d.data << endl; // 20 cout << sizeof(Derived) << endl; // 比非虚拟继承大（有额外开销） }虚拟继承后的内存布局（简化）
text
Derived对象（虚拟继承）： ┌─────────────────────┐ │ Base1部分（包含vptr）│ ├─────────────────────┤ │ Base2部分（包含vptr）│ ├─────────────────────┤ │ Derived部分 │ ├─────────────────────┤ │ Base部分（唯一一份） │ ← 共享的基类对象在末尾 └─────────────────────┘
虚拟继承通过间接访问来实现共享：派生类通过vptr或偏移量找到共享的基类子对象。
五、虚拟继承的开销
虚拟继承不是免费的：
| 开销类型 | 说明 |
|---|---|
| 内存 | 每个虚拟继承的子类增加一个隐藏指针（或偏移量） |
| 时间 | 访问虚拟基类成员需要间接寻址（多一次内存访问） |
| 复杂性 | 对象布局更复杂，构造/析构顺序有特殊规则 |
cpp
// 非虚拟继承：直接访问 cout << d.data; // 直接偏移 // 虚拟继承：间接访问 // 通过Base1中的vptr找到共享Base的位置，再访问data
六、完整例子：菱形继承对比
cpp
#include <iostream> using namespace std; // 非虚拟继承版本 namespace NonVirtual { class Base { public: int data = 10; }; class Base1 : public Base {}; class Base2 : public Base {}; class Derived : public Base1, public Base2 {}; void test() { Derived d; // d.data = 20; // ❌ 二义性 d.Base1::data = 20; d.Base2::data = 30; cout << "Base1::data = " << d.Base1::data << endl; cout << "Base2::data = " << d.Base2::data << endl; cout << "sizeof(Derived) = " << sizeof(Derived) << " 字节" << endl; } } // 虚拟继承版本 namespace Virtual { class Base { public: int data = 10; }; class Base1 : virtual public Base {}; class Base2 : virtual public Base {}; class Derived : public Base1, public Base2 {}; void test() { Derived d; d.data = 20; // ✅ 只有一份，没有二义性 cout << "data = " << d.data << endl; cout << "sizeof(Derived) = " << sizeof(Derived) << " 字节" << endl; } } int main() { cout << "=== 非虚拟继承 ===" << endl; NonVirtual::test(); cout << "\n=== 虚拟继承 ===" << endl; Virtual::test(); return 0; }典型输出（64位系统）：
text
=== 非虚拟继承 === Base1::data = 20 Base2::data = 30 sizeof(Derived) = 8 字节 === 虚拟继承 === data = 20 sizeof(Derived) = 16 字节
注意：虚拟继承版本虽然解决了二义性，但对象更大（多了用于定位共享基类的指针）。
七、虚拟继承的构造顺序
虚拟继承改变构造函数的调用顺序：
cpp
class Base { public: Base() { cout << "Base" << endl; } }; class Base1 : virtual public Base { public: Base1() { cout << "Base1" << endl; } }; class Base2 : virtual public Base { public: Base2() { cout << "Base2" << endl; } }; class Derived : public Base1, public Base2 { public: Derived() { cout << "Derived" << endl; } }; int main() { Derived d; }输出：
text
Base ← 虚拟基类最先构造 Base1 Base2 Derived
规则：虚拟基类在所有非虚拟基类之前构造，且只构造一次。
八、三个常见错误
1. 过度使用多继承
cpp
class Penguin : public Bird, public Fish, public Mammal { // 企鹅同时继承鸟、鱼、哺乳动物？这在现实中不合理 };大多数情况下，组合优于多继承。只在明确的“is-a”关系时才用继承。
2. 忘记虚拟继承导致重复基类
在菱形继承中，如果中间层忘记加virtual，Derived会有两份Base，通常不是你想要的效果。
3. 向下转型时的混乱
cpp
Derived* d = new Derived(); Base1* b1 = d; Base2* b2 = d; Base* b_from_b1 = b1; // 指向Base1中的Base部分 Base* b_from_b2 = b2; // 指向Base2中的Base部分 // b_from_b1 和 b_from_b2 指向不同的地址！（非虚拟继承时）
九、这一篇的收获
你现在应该理解：
多继承：一个类可以继承多个基类
二义性：多个基类有同名成员时，需要用
基类::成员指定菱形继承：一个基类通过两条路径被继承，导致重复成员和二义性
虚拟继承：用
virtual关键字让中间层共享同一个基类子对象，解决菱形继承问题虚拟继承有内存和时间开销，应谨慎使用
💡 小作业：实现
Person（有name属性）、Worker（有company属性）、Student（有school属性）。然后实现Intern同时继承Worker和Student。测试Intern对象能否访问name（来自Person）。注意：Worker和Student都应该虚拟继承Person。
下一篇预告：第19篇《多继承与菱形继承（二）：虚拟继承的内存模型与复杂性》——深入虚拟继承的内存布局、构造函数调用规则，以及为什么C++不推荐常规多继承（建议用组合+接口）。
