C++ 继承核心机制详解

在 Student 类的 Print 函数中，通过 Person::_num 明确访问父类的 _num 成员，避免混淆。实际编程中，应尽量避免在继承体系里定义同名成员，以免造成代码理解和维护上的困难。

派生类的默认成员函数

当我们定义派生类时，即便没有显式编写，编译器也会自动生成一些默认成员函数，主要包括以下几个方面：

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 {
//public:
//    friend void Display(const Person& p, const Student& s);
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 类及其他派生类中都是共享的，可通过类名或对象来访问。

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

单继承与多继承

单继承是指一个子类只有一个直接父类，关系简单明了。而多继承则是一个子类有两个或以上直接父类，这种情况虽然增加了代码复用的灵活性，但也引入了一些复杂问题。

菱形继承

菱形继承是多继承的一种特殊情况。以 class Assistant : public Student, public Teacher 为例，Student 和 Teacher 都继承自 Person，这样 Assistant 中就会出现 Person 成员的两份拷贝，导致数据冗余和二义性问题。比如在访问 Assistant 对象中来自 Person 的成员时，编译器无法明确确定访问的是哪一个 Person 成员。

菱形虚拟继承

为解决菱形继承的数据冗余和二义性问题，引入了虚拟继承。在 Student 和 Teacher 继承 Person 时使用虚拟继承（如 class Student : virtual public Person），就能确保在 Assistant 对象中只存在一份 Person 成员的拷贝。

虚拟继承通过虚基表指针和虚基表来管理基类成员的存储和访问，有效解决了上述问题，但也增加了一定的实现复杂度。D 对象中将 A 放到了对象组成的最下面，这个 A 同时属于 B 和 C，那么 B 和 C 如何去找到公共的 A 呢？这里是通过了 B 和 C 的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的 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;
}

总结与反思

继承在 C++ 中是把双刃剑。它极大地促进了代码复用，构建了清晰的类层次结构，但也带来了一些问题。多继承衍生出的菱形继承和复杂的底层实现，让代码复杂度和维护难度上升，这也是许多其他面向对象语言（如 Java）不采用多继承的原因。

在实际编程中，我们要谨慎选择继承和组合。继承是"is-a"关系，每个派生类对象都是一个基类对象；组合是"has-a"关系，一个类包含另一个类的对象。优先考虑对象组合，因为它耦合度低，代码维护性好，更符合'黑箱复用'原则；而继承适用于需要体现类之间层次关系，或实现多态的场景。