C++ 继承机制详解：从基础到虚拟继承

四、派生类的默认成员函数

编译器会自动为派生类生成一些默认成员函数，其执行顺序与初始化逻辑如下：

1. 构造函数：派生类构造函数必须先调用基类构造函数来初始化基类部分。若基类没有默认构造函数，必须在派生类构造函数的初始化列表中显式调用合适的基类构造函数。

   • 编译过程中，先初始化基类，再初始化派生类。派生类只初始化自己的成员。

2. 拷贝构造函数：派生类的拷贝构造函数需要调用基类的拷贝构造函数，完成基类成员的拷贝初始化。如果基类无拷贝构造函数，默认调用默认构造函数。

3. 赋值运算符函数：派生类的 operator= 必须调用基类的 operator= 来完成基类成员的复制，避免隐藏基类逻辑。

4. 析构函数：派生类的析构函数被调用完成后，会自动调用基类的析构函数。清理顺序遵循'先派生类后基类'，确保资源正确释放。无需手动调用基类析构函数，否则会导致二次析构错误。

![图示：构造与析构顺序]

五、继承与友元

友元关系在继承体系中是不能自动继承的。基类的友元不能访问子类的私有和保护成员。简单来说，'父亲的朋友不是你的朋友'，除非你单独声明其为朋友的友元。

class Student;
class Person {
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name;
};

class Student : public Person {
protected:
    int _stunNum;
};

void Display(const Person& p, const Student& s) {
    cout << p._name << endl;
    cout << s._stunNum << endl;
}

这里 Display 函数作为 Person 类的友元，能访问 Person 的保护成员，但对于 Student 类，它并不具备天然访问其保护成员的权限。

六、继承与静态成员

若基类定义了 static 静态成员，在整个继承体系中，无论派生出多少个子类，都只会存在一个该静态成员的实例。所有派生类共享这份数据。

class Person {
public:
    Person() { ++_count; }
public:
    static int _count;
};
int Person::_count = 0;

class Student : public Person {};

Person 类中的 _count 静态成员，在 Student 类及其他派生类中都是共享的，可通过类名或对象来访问。

七、复杂的菱形继承及菱形虚拟继承

（一）单继承与多继承

单继承结构简单明了。多继承则允许一个子类有两个或以上直接父类，增加了灵活性但也引入了复杂性。

![图示：多继承关系]

（二）菱形继承

菱形继承是多继承的一种特殊情况。例如 Assistant 同时继承自 Student 和 Teacher，而这两者又都继承自 Person。此时 Assistant 中会出现两份 Person 成员的拷贝，导致数据冗余和二义性问题。访问 Person 成员时，编译器无法确定访问的是哪一个副本。

![图示：菱形继承问题]

（三）菱形虚拟继承

为解决上述问题，引入虚拟继承。在中间层继承时使用 virtual 关键字（如 class Student : virtual public Person），确保最终派生类对象中只存在一份 Person 成员的拷贝。

虚拟继承通过虚基表指针和虚基表来管理基类成员的存储和访问。虽然解决了冗余问题，但也增加了一定的实现复杂度。

![图示：菱形虚拟继承内存模型]

八、总结与反思

继承是一把双刃剑。它极大地促进了代码复用，构建了清晰的类层次结构，但也带来了复杂度和维护难度。这也是许多其他语言（如 Java）不采用多继承的原因。

在实际编程中，我们要谨慎选择继承和组合：

• 继承是'is-a'关系，适用于体现类之间层次关系或实现多态的场景。
• 组合是'has-a'关系，优先考虑对象组合，因为它耦合度低，代码维护性好，更符合'黑箱复用'原则。

![图示：组合优于继承]

代码示例：虚拟继承测试

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class A {
public:
    A(const char* s) { cout << s << endl; }
    ~A() {}
};

class B : virtual public A {
public:
    B(const char* sa, const char* sb) : A(sa) { cout << sb << endl; }
};

class C : virtual public A {
public:
    C(const char* sa, const char* sb) : A(sa) { cout << sb << endl; }
};

class D : public B, public C {
public:
    D(const char* sa, const char* sb, const char* sc, const char* sd)
        : B(sa, sb), C(sa, sc), A(sa) { cout << sd << endl; }
};

int main() {
    D* p = new D("class A", "class B", "class C", "class D");
    delete p;
    return 0;
}

此示例展示了虚拟继承中基类构造函数的调用顺序，确保 A 类只被初始化一次。