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

这段代码编译时会遇到两个典型错误。第一个是关于类型未定义的提示，这是因为编译器在处理友元函数 Display 时向上查找 Student 类型，发现还没定义。虽然把 Student 放到 Person 前面能解决前向引用，但会导致 Person 定义时找不到 Student（相互依赖）。最稳妥的做法是在文件开头做前置声明。

第二个错误则是关键：基类的友元不能访问派生类的 protected/private 成员。这验证了友元关系不随继承传递。

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;

    // 非静态成员地址不同，说明各有一份
    cout << &p._name << endl;
    cout << &s._name << endl;
    cout << endl;

    // 静态成员地址相同，说明共用同一份
    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;
}

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

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

菱形继承是指一个派生类同时继承两个基类，而这两个基类又共同继承自一个顶层基类。这种结构会导致两个严重问题：数据冗余（顶层基类成员被继承两次）和二义性（访问成员时无法确定来源）。

2.1 菱形继承的坑

如果不加处理，访问顶层基类成员会出现歧义，必须显式指定路径，但这并不能解决数据冗余问题。

// 菱形继承 - 无虚继承
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.Student::_name = "李四";
    a.Teacher::_name = "王五";
    cout << a.Student::_name << endl;
    cout << a.Teacher::_name << endl;
}

2.2 虚继承：彻底解决之道

使用 virtual 关键字修饰中间基类对顶层基类的继承，可以确保顶层基类在最终派生类中只保留一份实例。

// 虚继承
class Person {
public:
    Person(const char* name) :_name(name) {}
public:
    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("张三", "李四", "王五");
    // 只有第一次 Person(name1) 生效，其他两次跳过
}

虚继承的关键细节：

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

3. 多继承中的指针偏移

在多继承中，不同类型的指针指向同一个对象时，地址可能不同。这是因为派生类对象内部包含了多个基类子对象的副本，它们的起始位置不同。

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;
    // p1 == p3 != p2
    return 0;
}

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

选择继承还是组合，取决于类之间的关系。

• 继承 (is-a)：体现'子类是父类的一种'。例如'学生是人'。属于白箱复用，子类了解基类内部实现，耦合度高。
• 组合 (has-a)：体现'一个类包含另一个类的对象'。例如'车包含轮胎'。属于黑箱复用，通过公开接口交互，隐藏内部细节，耦合度低。

选择原则：

• 优先使用组合：符合'高内聚、低耦合'原则，可维护性强，减少修改风险。
• 必要时使用继承：当明确存在 is-a 关系，或需要通过继承实现多态（如基类指针指向派生类）时，选择继承。避免为了复用少量代码强行继承导致耦合过高。

参考资料：

• https://zh.cppreference.com/w/cpp