C++ 继承中友元、静态成员与菱形继承的坑与解法

要点很直接：

• 基类友元只够得着基类的 private/protected 成员；
• 要访问派生类成员，必须在派生类里重新声明友元；
• 友元是'一对一'的，没有传递性。

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

静态成员（变量或函数）在继承树中只有一份，基类和所有派生类共享。不像普通成员，每个对象独有一份。

#include <iostream>
#include <string>
using namespace std;

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

    // 静态成员地址相同——共享一份
    cout << &p._count << endl;
    cout << &s._count << endl << endl;

    cout << p._count << endl;      // 1
    cout << s._count << endl;      // 1

    Person::_count++;              // 通过类域修改
    cout << Person::_count << endl;   // 2
    cout << Student::_count << endl;  // 2，一起变了
}

记住几点：

• 静态成员变量必须在类外定义并初始化；
• 静态成员函数只能碰静态成员，不能访问非静态数据；
• 无论是通过基类还是派生类指定类域修改静态成员，影响的都是全局唯一的那份；
• 整个继承体系共享同一个静态成员。

多继承及菱形继承：内存布局与虚继承

单继承 vs 多继承

单继承就是一个直接基类。多继承是多个直接基类，对象内存里先放的基类往后排，最后放派生类自己。顺序就是继承列表中声明的顺序。

class Student {
protected:
    string _name;
};

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

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

菱形继承的麻烦

菱形继承：两个中间类继承同一个顶层基类，最后再被一个类继承。这会导致：

• 数据冗余：顶层基类的成员被继承两次；
• 二义性：访问时不知道走哪条路径。

支持多继承就会有菱形问题，Java 直接禁了多继承。所以平时别主动设计出这种结构。但语言层面提供了 virtual 来解决。

先看二义性演示：

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 Test() {
    Assistant a;
    // a._name = "张三";   // 编译报错：不明确
    a.Student::_name = "李四";
    a.Teacher::_name = "王五";   // 只能这样显式指定，但数据还是两份
}

虚继承：让顶层基类只留一份

在中间类继承顶层基类时加上 virtual，就会让最终派生类里只存在一份顶层基类的成员。同时，顶层基类的构造函数由最终派生类负责调用，中间类的初始化列表中虽然也写了顶层构造函数，但会被忽略，除非最终派生类没调用。

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

class Student : virtual public Person {   // virtual 加在这里
public:
    Student(const char* name, int num) : Person(name), _num(num) {}
protected:
    int _num;
};

class Teacher : virtual public Person {   // 同样加 virtual
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 Test() {
    Assistant a("张三", "李四", "王五");
    // a 里 _name 是 "张三"，另外两次 Person 调用被跳过
}

虚继承的关键细节：

• virtual 只加在中间基类继承顶层基类的地方，最后那个派生类不需要加。
• 虚继承下，顶层基类的构造由最终派生类负责，中间类的构造调用中即使写了也会跳过（若不放心，可只在最终派生类写顶层初始化）。
• 底层会多一张虚基表，增加复杂度，所以尽量别搞菱形继承。

多继承里的指针偏移：一道题

下面说法正确的是 ( 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;
}

p1 和 p3 都指向对象的起始地址，因为 Base1 是第一个被继承的，所以和 Derive 开头重合。p2 指向 Base2 子对象，需要跳过 Base1 那部分，所以地址会高一些。也就印证了前面的内存模型。

继承与组合：怎么选

• 继承 (is-a)：子类是父类的一种，例如学生是人。白箱复用，子类知道父类的非私有实现。
• 组合 (has-a)：一个类包含另一个类的对象，例如汽车有轮胎。黑箱复用，只通过公开接口交互，内部细节不可见。

实际编码里，优先用组合。组合耦合低，改动风险小，更符合'高内聚、低耦合'。除非关系明显是 is-a，或者需要多态（基类指针/引用操作派生类对象），才选继承。别为了偷几行代码就搞继承，把耦合弄得很紧。菱形继承这种就更应该避免。

C++ 继承相关的特殊规则差不多就是这些。友元不可继承，静态成员共享，多继承布局由声明顺序决定，菱形继承用虚继承保底——但最好还是别那么写。把握住这些，继承机制的坑就能少踩很多。

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