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

编译时会遇到两个报错。第一个报错提示缺少逗号或类型问题，其实是因为编译器向上查找时找不到 Student 的类型说明。虽然把 Student 放到 Person 上面看似可行，但这会导致循环依赖（相互依赖）。解决方法是在最开始前置声明一下 Student。

第二个报错则明确说明了：基类的友元是不能被派生类继承的。所以解决方法就是在派生类也进行友元声明。

2. 正确版本

// 前置声明 Student(为了让编译器走到友元函数时能向上查找到 Student)
class Student;

class Person {
public:
    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 _stuid = 123; // 学号
};

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

void Test1() {
    Person p;
    Student s;
    Display(p, s);
}

int main() {
    Test1();
    return 0;
}

核心结论：

• 基类友元仅能访问基类的 private/protected 成员；
• 若需访问派生类成员，必须在派生类中重新声明友元；
• 友元关系是**"一对一的"**，不能自动传递。

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

基类的静态成员（静态变量/静态函数）在整个继承体系中仅存在一份，派生类和基类共享该成员，不会因为继承而产生多个副本。这与非静态成员不同 —— 非静态成员每个对象独一份。

也就是说对于基类的静态成员而言，对其进行初始化则说所有派生类的该成员都会被初始化成相同值，并且一个类的静态成员进行修改也会影响其他所有相关的派生类和基类。

// 静态成员
class Person {
public:
    string _name;
    static int _count;
};

int Person::_count = 1;

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

void Test2() {
    Person p;
    Student s;
    
    // 这里的运行结果可以看到非静态成员的_name 地址是不一样的
    // 说明非静态成员派生类继承下来了，基类和派生类对象各有一份不一样的
    cout << &p._name << endl;
    cout << &s._name << endl;
    cout << endl;
    
    // 这里的运行结果可以看到静态成员的_count 地址是一样的
    // 说明派生类和基类共用同一份静态成员，所以对其中一个修改就会影响所有相关基类和派生类的静态成员
    cout << &p._count << endl;
    cout << &s._count << endl;
    cout << endl;
    
    cout << p._count << endl;
    cout << s._count << endl;
    cout << endl;
    
    Person::_count++; // 公有的情况下，基类派生类指定类域都可以访问静态成员
    // 原因在前面的学习已经讲解过了，静态成员不属于任何一个对象，是存在静态区的
    // 可以把静态成员看成全局变量只是被类域所限制而已，所以要访问就需要使用域作用限定符来突破类域访问
    cout << Person::_count << endl;
    cout << Student::_count << endl;
    cout << endl;
}

int main() {
    Test2();
    return 0;
}

核心结论：

• 静态成员变量必须在类外初始化，否则会触发链接错误；
• 静态成员函数只能访问静态成员变量，无法访问非静态成员；
• 公有的情况下，基类派生类指定类域也可以访问静态成员；
• 继承体系中所有类（基类，派生类）共享同一份静态成员，修改一处会影响全局。

三、多继承及菱形继承问题：本质特点与解决方案

1. 单继承与多继承模型

单继承：一个派生类只有一个直接基类时称这个继承关系为单继承。

多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承。多继承对象在内存中的模型是：先继承的基类在前面，后继承的基类在后面，派生类成员放在最后面。

// 多继承
class Student {
protected:
    string _name; // 姓名
};

class Teacher {
protected:
    int _id = 123; // 职工编号
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse; // 主修课程
};

void Test3() {
    Assistant a;
}

int main() {
    Test3();
    return 0;
}

2. 菱形继承：虚继承解决'数据冗余'与'二义性'

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

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

支持多继承就一定会有菱形继承，像 Java 就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

2.1 菱形继承出现的坑 (解决二义性问题)

// 菱形继承
// 顶层基类
class Person {
public:
    string _name; // 会被 Assistant 继承两次
};

// 中间基类 1
class Student : public Person {
protected:
    int _num; // 学号
};

// 中间基类 2
class Teacher : public Person {
protected:
    int _id; // 职工编号
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse; // 主修课程
};

void Test3() {
    Assistant a;
    // a._name = "张三"; // error C2385: 对'_name'的访问不明确
    // （到底是 Student::_name 还是 Teacher::_name 呢？）
    a.Student::_name = "李四";
    a.Teacher::_name = "王五"; // 只能显式指定，但数据冗余仍存在，没有解决
    cout << a.Student::_name << endl; // 输出李四
    cout << a.Teacher::_name << endl; // 输出王五
}

int main() {
    Test3();
    return 0;
}

2.2 虚继承：彻底解决菱形继承问题

// 虚继承
// 顶层基类
class Person {
public:
    Person(const char* name) :_name(name) { }
public:
    string _name; // 姓名
};

// 中间基类 1：虚继承 Person（添加 virtual）
// virtual，谁 (Person) 被继承多次就在继承谁 (Person) 的那些子类 (Student) 加
class Student : virtual public Person {
public:
    Student(const char* name, int num) : Person(name), _num(num) { }
    // 在虚继承下，中间基类会暂时不初始化顶层基类，只会初始化自己的成员变量
protected:
    int _num; // 学号
};

// 中间基类 2：虚继承 Person（添加 virtual）
class Teacher : virtual public Person {
public:
    Teacher(const char* name, int id) : Person(name), _id(id) { }
    // 在虚继承下，中间基类会暂时不初始化顶层基类，只会初始化自己的成员变量
protected:
    int _id; // 职工编号
};

// 最终派生类：菱形继承（Person 成员会被合并成仅一份）
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; // 主修课程
};

void Test4() {
    Assistant a("张三", "李四", "王五");
    // 思考一下这里 a 对象中 _name 是'张三', '李四', '王五'中的哪一个？
    // 上面有三次 Person(name)，但其实就只有在 Assistant 里一次，其它两次会跳过。
    // 所以是张三
}

int main() {
    Test4();
    return 0;
}

虚继承的关键细节：

• virtual 仅需添加在中间基类继承顶层基类时，最终派生类继承中间基类时不需要添加。
• 虚继承下，顶层基类的构造函数由最终派生类负责调用，中间基类的构造函数不再初始化顶层基类 (但还是需要写出来的)。
• 虚继承时会增加底层复杂度 (虚基表)，因此尽量避免设计菱形继承结构，除非业务逻辑必须如此。

3. 多继承中指针偏移问题

下面说法正确的是 ( C )

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

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;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

图解如下：

四、继承与组合：C++ 代码复用的核心方式对比

• 继承 (is-a 关系)：体现'子类是父类的一种'的逻辑，例如'Student 是 Person 的一种'、'BMW 是 Car 的一种'。派生类直接继承基类的成员（属性/方法），可扩展自身独有功能，属于**'白箱复用'** —— 子类能访问基类非私有成员，了解其内部实现细节。
• 组合 (has-a 关系)：体现'一个类包含另一个类的对象'的逻辑，例如'Car 包含 Tire'、'Computer 包含 CPU'。组合类通过调用被包含对象的公开接口实现复用，被包含类的内部细节对组合类隐藏，属于**'黑箱复用'**。

选择原则：

• 优先使用组合：组合的低耦合特性更符合**'高内聚、低耦合'的设计原则，代码可维护性更强，尤其在复杂系统中，能减少类间依赖带来的修改风险**。不过也不太那么绝对，类之间的关系就只适合继承 (is-a) 那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承 (is-a) 也适合组合 (has-a)，就用组合。
• 必要时使用继承：当类间明确存在'is-a'关系，或需要通过继承实现多态（如基类指针指向派生类对象）时，选择继承；避免为了复用少量代码而强行使用继承，导致耦合度升高。

总结

参考文档： https://zh.cppreference.com/w/cpp