C++ 继承机制详解：从基础到多态应用

注意：同一作用域才能构成重载。这里两个 fun 只是隐藏关系，不是重载。

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

设计理念：父干父的活，子干子的活。

1. 构造函数

子类必须调父类的构造函数来初始化父类成员。默认情况下，在初始化列表自动调用父类的默认构造函数。若父类不提供默认构造函数，则必须手动指定。

规定：子类的构造函数中，不能在初始化列表显示初始化父类成员（因为那是基类部分），只能在构造函数体内初始化，或者在初始化列表中调用基类构造函数。

class Person {
public:
    Person(const char* name) : _name(name) { cout << "Person()" << endl; }
    ~Person() { cout << "~Person()" << endl; }
protected:
    string _name;
};

class Student : public Person {
public:
    // 必须在初始化列表中调用基类构造函数
    Student(const char* name, int id) : Person(name), _id(id) {}
protected:
    int _id;
};

调试发现，在初始化列表先走 Person(name)，说明继承的成员声明在自己的成员之前。初始化顺序是按声明顺序来的。

2. 拷贝构造

必须调父类的拷贝构造。子类对象可以传给父类对象的指针/引用，所以可以直接传子类对象给父类拷贝构造。

class Student : public Person {
public:
    Student(const Student& s) : Person(s), _id(s._id) {}
    // ... 省略其他代码
};

如果删去父类拷贝构造调用，默认不会调拷贝构造函数，而是调默认构造函数，这会导致数据不一致。

3. 赋值重载

class Student : public Person {
public:
    Student& operator=(const Student& s) {
        if (this != &s) {
            Person::operator=(s); // 显式调用父类赋值，避免隐藏
            _id = s._id;
        }
        return *this;
    }
};

4. 析构函数

构造、拷贝、赋值要显示调用。析构函数是个特殊，为保证析构顺序，会自动调。

为什么不能手动调用父类析构？ 由于多态的原因，析构函数的函数名被特殊处理了。如果手动调用 Person::~Person()，可能会导致重复析构或顺序错误。总共 2 个对象，调了 4 次析构函数就是典型的错误示范。

正确的做法：子类析构函数完成后，系统自动调用父类析构，这样就保证了先子后父的析构顺序。为什么要保证先子后父？因为子类中有可能用到父类成员，父类不可能用到子类。如果先析构父类，子类再访问父类成员就会出错。

五、继承与友元

友元关系不能继承。父类友元不能访问子类私有和保护成员。

class Student;
class Person {
    friend void Display(const Person& p, const Student& s);
protected:
    string _name;
};
class Student : public Person {
    friend void Display(const Person& p, const Student& s);
protected:
    int _stuNum;
};
void Display(const Person& p, const Student& s) {
    cout << p._name << endl;
    cout << s._stuNum << endl; // 需要 Student 也声明友元
}

屏蔽掉 Student 中的友元声明会报错，因为友元关系不具备传递性。

六、继承与静态成员

父类定义了 static 静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个 static 成员实例，在子类中不会单独拷贝一份。

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

class Student : public Person {};
// ... 使用逻辑同上

七、多继承、菱形继承、菱形虚拟继承

实践中可以谨慎用多继承，不要用菱形继承。

单继承：一个子类只有一个直接父类。 多继承：一个子类有两个或以上直接父类。 菱形继承：是多继承的一种特殊情况，会导致数据冗余和二义性。

class Person { public: string _name; int _age; };
class Student : public Person { protected: int _num; };
class Teacher : public Person { protected: int _id; };
class Assistant : public Student, public Teacher { protected: string _majorCourse; };

int main() {
    Assistant as;
    as._age = 19; // 报错：对'_age'的访问不明确
    return 0;
}

二义性可以通过指定访问路径解决（如 as.Student::_age），但这违背常理且维护困难。

虚拟继承解决了数据冗余和二义性问题。

class Student : virtual public Person { ... };
class Teacher : virtual public Person { ... };

这样设计后，Assistant 中只有一份 Person 的副本。原理是通过虚基表（vptr/vtable）机制，先取到偏移量，计算 _age 在对象中的地址，再访问。

八、继承和组合

class C {}; 
class D : public C {}; // 继承
class E { private: C _cc; }; // 组合

继承：白箱复用，父类的内部细节对子类可见；耦合度高。改变父类的成员，子类要跟着改。 组合：黑箱复用，对象的内部细节不可见；耦合度低。

实践中多用组合。继承和组合都可以，就用组合；更适合用继承的用继承；实现多态，必须用继承。

• public 继承是 is-a 的关系：每个子类对象一定是父类对象（如教师、学生都是人）。
• 组合是 has-a 的关系：E 组合了 C，每个 E 对象中都有一个 C 对象（如车有轮胎）。

以上就是 C++ 继承机制的核心内容。理解这些概念对于编写健壮、可扩展的代码至关重要。