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

三、继承中的作用域

作用域查找发生在编译时。子类和父类拥有独立的类域。当存在同名成员时，子类成员会隐藏父类成员，这称为隐藏或重定义。

注意： 在子类成员函数中，如果想访问被隐藏的父类成员，需要使用作用域解析运算符 ::。

class Person {
public:
    void fun() { cout << "Person::func()" << endl; }
protected:
    int _num = 111;
};

class Student : public Person {
public:
    void fun(int) { cout << "Student::func(int)" << endl; } // 重载了 fun
    void Print() {
        cout << _num << endl;          // 访问子类 _num (999)
        cout << Person::_num << endl;  // 显式访问父类 _num (111)
    }
protected:
    int _num = 999;
};

int main() {
    Student s;
    s.fun(1);       // 调用子类版本
    s.Person::fun(); // 显式调用父类版本
    return 0;
}

建议： 尽量避免在继承体系中定义同名成员，以免引起混淆。

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

设计理念遵循'父干父的活，子干子的活'。

1. 构造函数

子类构造函数必须初始化父类成员。不能在初始化列表中直接初始化父类成员变量，而应调用父类构造函数。

class Person {
public:
    Person(const char* name) : _name(name) {}
protected:
    string _name;
};

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

若父类没有默认构造函数，子类必须显式调用带参构造函数，否则编译报错。

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. 析构函数

析构顺序至关重要：先析构子类，再析构父类。这是因为子类可能依赖父类资源。

class Student : public Person {
public:
    ~Student() {
        // 不要手动调用 Person::~Person()
        // 编译器会自动按逆序调用父类析构
    }
};

如果手动调用父类析构，可能导致重复析构或顺序错误。编译器保证自动调用的顺序是正确的。

五、继承与友元

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

class Student;
class Person {
    friend void Display(const Person&, const Student&);
};
class Student : public Person {
    friend void Display(const Person&, const Student&);
};
// 需要在两个类中都声明友元才能互相访问

六、继承与静态成员

静态成员属于类而非对象。无论派生出多少个子类，整个继承体系只有一个静态成员实例。

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

// 子类不会单独拷贝一份 _count

七、多继承与菱形继承

多继承

一个子类可以有多个直接父类。虽然功能强大，但容易引发复杂问题，实践中需谨慎使用。

菱形继承问题

当出现菱形继承结构时（如 A -> B, C -> D），会导致两个主要问题：

1. 数据冗余：基类成员在最终子类中存在多份副本。
2. 二义性：访问基类成员时不知道应该走哪条路径。

class Person { public: int _age; };
class Student : public Person { int _num; };
class Teacher : public Person { int _id; };
class Assistant : public Student, public Teacher { /* ... */ };

// as._age = 19; // 报错：对_age 的访问不明确

虚拟继承解决方案

使用 virtual 关键字进行虚继承，确保基类在内存中只有一份实例。

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

虚拟继承通过引入间接寻址（虚基表）来解决冗余和二义性问题，但会增加一定的运行时开销。

八、继承和组合

继承 vs 组合

• 继承（Inheritance）：白箱复用，耦合度高。表示 is-a 关系（如学生是人）。
• 组合（Composition）：黑箱复用，耦合度低。表示 has-a 关系（如车有轮胎）。

class E {
private:
    C _cc; // 组合
};

最佳实践： 优先使用组合。只有在明确表达 is-a 关系且需要多态支持时才使用继承。

本文涵盖了 C++ 继承的核心知识点。理解这些机制对于编写高质量、可维护的面向对象代码至关重要。