C++ 继承进阶：友元、静态成员与菱形继承解析

第二个报错（无法访问 _stuid）明确说明了：基类的友元不能被派生类继承。解决方法是在派生类中也声明友元。

2. 正确写法

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 _stuid = 123;
};

void Display(const Person& p, const Student& s) {
    cout << p._name << endl;
    cout << s._stuid << endl; // 现在可以正常访问
}

int main() {
    Person p;
    Student s;
    Display(p, s);
    return 0;
}

核心要点：友元是'一对一'的特权，不会随继承自动传递。若需访问派生类成员，需在派生类中显式授予权限。

二、静态成员 —— 继承体系中的共享性

基类的静态成员（变量或函数）在整个继承体系中仅存在一份。这与非静态成员不同，后者每个对象都有独立副本。

这意味着对静态成员的修改会影响所有相关的基类和派生类对象。我们可以通过地址对比来验证这一点。

class Person {
public:
    string _name;
    static int _count;
};

int Person::_count = 1;

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

void Test() {
    Person p;
    Student s;

    // 非静态成员地址不同
    cout << &p._name << endl;
    cout << &s._name << endl;

    // 静态成员地址相同，说明共享同一份内存
    cout << &p._count << endl;
    cout << &s._count << endl;

    // 通过类域访问
    cout << Person::_count << endl;
    cout << Student::_count << endl;

    Person::_count++; // 修改一处，全局生效
}

注意：静态成员必须在类外初始化，且静态函数只能访问静态成员变量，不能访问非静态成员。

三、多继承及菱形继承问题

1. 单继承与多继承模型

• 单继承：一个派生类只有一个直接基类。
• 多继承：一个派生类有两个或以上直接基类。多继承对象的内存布局通常是：先继承的基类在前，后继承的基类在后，派生类成员在最后。

2. 菱形继承：数据冗余与二义性

菱形继承是指一个派生类同时继承两个基类，而这两个基类又共同继承自一个顶层基类。这种结构会导致两个核心问题：

1. 数据冗余：顶层基类的成员被最后的派生类继承了两次。
2. 二义性：访问成员时无法确定属于哪个基类。

解决方案：虚继承

使用 virtual 关键字进行虚继承，可以确保顶层基类在最终派生类中只保留一份实例。

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

// 中间基类虚继承
class Student : virtual public Person {
public:
    Student(const char* name, int num) : Person(name), _num(num) {}
protected:
    int _num;
};

class Teacher : virtual public Person {
public:
    Teacher(const char* name, int id) : Person(name), _id(id) {}
protected:
    int _id;
};

// 最终派生类
// 关键点：虚继承下，顶层基类的构造由最终派生类显式调用
// 中间基类的构造函数虽然写了，但不会初始化顶层基类
// 只有 Assistant 里的 Person(name1) 会真正执行

class Assistant : public Student, public Teacher {
public:
    Assistant(const char* name1, const char* name2, const char* name3)
        : Person(name1), Student(name2, 1), Teacher(name3, 2), _majorCourse("计算机") {}
protected:
    string _majorCourse;
};

int main() {
    Assistant a("张三", "李四", "王五");
    // 此时 a._name 为 "张三"
    return 0;
}

虚继承细节：

• virtual 只需加在中间基类继承顶层基类时。
• 顶层基类构造函数由最终派生类负责调用。
• 虚继承会增加底层复杂度（涉及虚基表），因此除非业务必须，否则尽量避免设计菱形结构。

3. 多继承指针偏移

在多继承中，指向不同基类的指针地址可能不同。例如，Base2* 指向的对象起始地址相对于 Derive* 会有偏移。

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };

int main() {
    Derive d;
    Base1* p1 = &d;   // 偏移量为 0
    Base2* p2 = &d;   // 偏移量不为 0，指向 Base2 部分
    Derive* p3 = &d;  // 偏移量为 0
    // p1 == p3 != p2
}

四、继承与组合：代码复用的核心选择

• 继承 (is-a)：体现'子类是父类的一种'。派生类直接继承基类成员，属于'白箱复用'。适用于明确的层级关系或多态需求。
• 组合 (has-a)：体现'一个类包含另一个类的对象'。通过调用公开接口复用，属于'黑箱复用'。

选择原则：优先使用组合。组合的低耦合特性更符合高内聚、低耦合的设计原则，能减少类间依赖带来的维护风险。只有当存在明确的 is-a 关系或需要实现多态时，才考虑继承。

总结

C++ 继承的核心价值在于实现类级别的代码复用，但上述特殊场景恰恰是理解其机制深度的关键。从友元的不可继承性，到静态成员的共享，再到菱形继承的虚继承方案，都体现了 C++ 在封装、复用与安全性之间的平衡设计。