C++ 继承入门(下)：友元、静态成员与菱形继承的底层逻辑

#include<iostream> #include<vector> using namespace std; //友元——友元不能被继承 class Person { public: friend void Display(const Person& p, const Student& s); protected: string _name = "张三"; //姓名 }; class Student : public Person { 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; }

我们会发现出现了上面两个报错，第二个报错我们倒是好理解，但是第一个报错原因可能很多人会不理解是什么意思。

通常如果出现这种缺少“，”这种报错，但是检查的时候没有漏掉逗号，有一种情况就是类型出现了问题(没有类型)，但这是为什么呢？
原因就在于编译器当看到一个类型时是向上查找，所以当编译器走到友元函数的代码时看到了Student 这个类型，就会向上查找，但是上面却没有这个类型的说明就会报错。
那有些人就会说了：直接把 Student 放到 Person 上面不就行了，但是 Student 是 Person 的继承类，如果把 Student 放到 Person 上面，当编译器走到 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; //error C2248 : “Student::_stuid” : 无法访问 protected 成员(在“Student”类中声明) //说明基类的友元不能被派生类继承，要使用就需要在派生类也进行友元声明 } 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） //virtual，谁(Person)被继承多次就在继承谁(Person)的那些子类(Teacher)加 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” 关系，或需要通过继承实现多态（如基类指针指向派生类对象）时，选择继承；避免为了复用少量代码而强行使用继承，导致耦合度升高。

结束语

到此，C++继承入门就全部讲解完了。C++ 继承的核心价值在于实现类级别的代码复用，但友元、静态成员、菱形继承这些特殊场景，恰恰是理解继承机制 “深度” 的关键。从友元关系的 “不可继承性”，到静态成员的 “全局共享特性”，再到菱形继承中虚继承对数据冗余与二义性的解决，都表现出 C++ 对 “封装”“复用” 与 “安全性” 的平衡设计。希望对大家学习C++能有所收获！

C++参考文档：
https://legacy.cplusplus.com/reference/
https://zh.cppreference.com/w/cpp
https://en.cppreference.com/w/