C++ 继承的隐蔽角落：友元、静态成员与菱形继承

修正版如下：

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;
}

要点就一条：友元关系不会沿着继承链传递，每个类需要独立授权。

静态成员：整个继承体系只有一份

静态成员变量或函数在基类和所有派生类之间是共享的，不会每个类存一份。这和非静态成员完全不同——非静态成员是每个对象独有一块内存。

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;
    
    cout << &p._name << endl;
    cout << &s._name << endl;  // 两个 _name 地址不同
    cout << endl;
    
    cout << &p._count << endl;
    cout << &s._count << endl; // 两个 _count 地址相同
    cout << endl;
    
    cout << p._count << endl;
    cout << s._count << endl;
    cout << endl;
    
    Person::_count++;
    cout << Person::_count << endl;
    cout << Student::_count << endl; // 都变成了 2
}

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

从输出能看出来，_count 始终只有一份，修改一处，所有通过基类或派生类访问到的值都变了。这也解释了为什么静态成员必须在类外初始化——它不属于任何一个对象，而是属于整个类群。

多继承与菱形继承

多继承的对象内存布局

多继承很简单，就是一个派生类同时从两个以上基类继承。内存里，基类子对象按声明顺序排列，派生类自己的成员放在最后。

class Student {
protected:
    string _name;
};

class Teacher {
protected:
    int _id = 123;
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse;
};

void Test3() {
    Assistant a;
}

Assistant 对象的内存大概长这样：先是 Student 部分，然后 Teacher 部分，最后是 _majorCourse。

菱形继承的麻烦

菱形继承是经典的'钻石'形状：一个顶层基类，两个中间基类分别继承它，最后一个类同时继承这两个中间基类。这会带来两个问题：

• 数据冗余：顶层基类的成员被最终派生类继承了两次。
• 二义性：访问成员时编译器不知道该用哪份。

class Person {
public:
    string _name;
};

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

class Teacher : public Person {
protected:
    int _id;
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse;
};

void Test3() {
    Assistant a;
    // a._name = "张三"; // 错误：不明确
    a.Student::_name = "李四";
    a.Teacher::_name = "王五";
    cout << a.Student::_name << endl; // 李四
    cout << a.Teacher::_name << endl; // 王五
}

你可以通过 Student:: 或 Teacher:: 显式指定来解决二义性，但冗余依然存在——_name 在对象里存了两份。C++ 提供虚继承来从根本上解决这个问题。

虚继承：让顶层基类只出现一次

虚继承的写法是在中间基类继承顶层基类时加上 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;
};

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
}

关键点：

• virtual 只加在中间基类处，最终派生类继承时不需要再加。
• 顶层基类的构造函数由最终派生类负责调用，中间基类的构造函数列表里虽然也写了，但实际会跳过，仅初始化自己的特有成员。
• 底层实现依赖虚基表，会引入一定的运行时开销，所以不到万不得已别设计菱形继承。

多继承中的指针偏移

来看一道常见的选择题：

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;
}

正确选项是 p1 == p3 != p2。因为 Derive 对象先存放 Base1 部分，再存放 Base2 部分，所以 p1 和 p3 都指向对象起始，p2 会偏移。

复用：继承还是组合？

C++ 里代码复用的两种主要方式是继承和组合。

• 继承 表示 'is-a' 关系——学生是人，宝马是车。派生类可以直接使用基类的非私有成员，属于'白箱复用'，因为你对基类的内部可见。
• 组合 表示 'has-a' 关系——车有轮胎，电脑有CPU。组合类通过被包含对象的公开接口来实现功能，内部细节不可见，属于'黑箱复用'。

实践中，一般优先考虑组合，因为它耦合度更低，修改时不容易影响其他类。但如果类之间天然存在 is-a 关系，或者需要利用多态（基类指针指向派生类对象），那就用继承。原则上，能用组合解决问题就不要用继承，反过来，如果只有继承才能表达清楚业务语义或多态需求，那就继承。

继承提供了强大的代码复用机制，但友元、静态成员和菱形继承这些细节如果不弄清楚，很容易写出带坑的代码。理解它们，才能在设计时做出合适的选择。

参考：

• https://legacy.cplusplus.com/reference/
• https://zh.cppreference.com/w/cpp
• https://en.cppreference.com/w/