C++ 继承详解：语法、陷阱与最佳实践

一、继承是什么？解决了什么问题？

在面向对象编程中，复用是永恒的追求。函数实现了代码块的复用，而继承将复用提升到了类设计的层次。

以设计 Student（学生）和 Teacher（老师）两个类为例，两者都有姓名、地址、电话、年龄等共性属性，以及身份认证等共性行为；但也有差异 —— 学生有学号和学习方法，老师有职称和授课方法。

如果不使用继承，代码会存在大量冗余：

// 学生类
class Student {
public:
    void identity() {} // 重复定义
    void study() {}
protected:
    string _name = "peter";
    string _address;
    string _tel;
    int _age = 18;
    int _stuid;
};

// 老师类
class Teacher {
public:
    void identity() {} // 重复定义
    void teaching() {}
protected:
    string _name = "张三";
    string _address;
    string _tel;
    int _age = 18;
    string _title;
};

identity() 方法和 4 个属性完全重复，增加了代码量且埋下修改隐患。继承的核心思想是将共性抽离成基类（父类），让派生类（子类）继承特性并补充独有内容。

重构后的代码：

// 基类：抽离共性
class Person {
public:
    void identity() { cout << "身份认证：" << _name << endl; }
protected:
    string _name = "张三";
    string _address;
    string _tel;
    int _age = 18;
};

// 派生类 Student：继承 Person
class Student : public Person {
public:
    void study() {}
protected:
    int _stuid;
};

// 派生类 Teacher：继承 Person
class Teacher : public Person {
public:
    void teaching() {}
protected:
    string _title;
};

int main() {
    Student s;
    Teacher t;
    s.identity(); // 输出：身份认证：张三
    t.identity(); // 输出：身份认证：张三
    return 0;
}

二、继承的语法细节：三种继承方式与访问控制

基类成员在派生类中的访问权限，由基类的访问限定符和继承方式共同决定。

2.1 继承的基本格式

class 派生类名 : 继承方式 基类名 {
    // 派生类的成员
};

例如 class Student : public Person 表示 Student 以 public 方式继承 Person。

2.2 继承方式如何影响访问权限？

基类成员类型	public 继承	protected 继承	private 继承
public 成员	派生类 public	派生类 protected	派生类 private
protected 成员	派生类 protected	派生类 protected	派生类 private
private 成员	不可见	不可见	不可见

关键点：

1. 不可见不是不继承：基类 private 成员会被继承到对象中，但禁止访问。
2. 保护成员（protected）的意义：不想被类外访问，但需让派生类访问时使用。

实例验证：

class Person {
public:
    void Print() { cout << _name << endl; }
protected:
    string _name = "张三";
private:
    int _age = 18;
};

class Student : public Person {
public:
    void Test() {
        Print();      // 可以访问
        _name = "李四"; // 可以访问
        // _age = 20;   // 编译报错
    }
};

int main() {
    Student s;
    s.Print();      // 可以访问
    // s._name = "王五"; // 编译报错
    return 0;
}

2.3 实际开发中的继承方式选择

• 默认继承方式：class 默认为 private，struct 默认为 public（建议显式写出）。
• 推荐用法：几乎只用 public 继承。protected 或 private 继承限制后续扩展，维护性差。

三、继承中的核心陷阱：作用域与隐藏规则

基类和派生类拥有独立的作用域，同名成员会触发'隐藏'规则。

3.1 什么是'隐藏'？

• 属性隐藏：派生类同名属性屏蔽基类属性直接访问。
• 方法隐藏：只要方法名相同即构成隐藏（不同于重载，重载要求同一作用域）。

class Person {
protected:
    string _name = "小李子";
    int _num = 111; // 身份证号
};

class Student : public Person {
public:
    void Print() {
        cout << "姓名：" << _name << endl;       // 继承的_name
        cout << "身份证号：" << Person::_num << endl; // 加作用域
        cout << "学号：" << _num << endl;         // 派生类的_num，隐藏基类
    }
protected:
    int _num = 999; // 学号
};

int main() {
    Student s;
    s.Print();
    return 0;
}

3.2 区分重载与隐藏

class A {
public:
    void func() { cout << "func()" << endl; }
};

class B : public A {
public:
    void func(int i) { cout << "func(int i): " << i << endl; }
};

int main() {
    B b;
    b.func(10);     // 运行：调用 B::func
    b.func();       // 编译报错：B::func 隐藏了 A::func
    b.A::func();    // 解决方案：显式加作用域
    return 0;
}

四、派生类的默认成员函数：初始化与清理的顺序

4.1 核心规则

1. 构造函数：派生类构造必须先调用基类构造。若基类无默认构造，必须在初始化列表中显式调用。
2. 拷贝构造：先调用基类拷贝构造。
3. 赋值重载：先调用基类赋值重载（注意显式加作用域避免隐藏）。
4. 析构函数：执行完派生类逻辑后，自动调用基类析构。

4.2 实例演示

class Person {
public:
    Person(const char* name = "peter") : _name(name) { cout << "Person 构造" << endl; }
    Person(const Person& p) : _name(p._name) { cout << "Person 拷贝构造" << endl; }
    Person& operator=(const Person& p) { if (this != &p) _name = p._name; cout << "Person 赋值重载" << endl; return *this; }
    ~Person() { cout << "Person 析构" << endl; }
protected:
    string _name;
};

class Student : public Person {
public:
    Student(const char* name, int num) : Person(name), _num(num) { cout << "Student 构造" << endl; }
    Student(const Student& s) : Person(s), _num(s._num) { cout << "Student 拷贝构造" << endl; }
    Student& operator=(const Student& s) {
        if (this != &s) { Person::operator=(s); _num = s._num; }
        cout << "Student 赋值重载" << endl; return *this;
    }
    ~Student() { cout << "Student 析构" << endl; }
protected:
    int _num;
};

int main() {
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
    return 0;
}

运行结果顺序：构造 Person→Student，析构 Student→Person。

4.3 实现不能被继承的类

• C++98 方式：将基类构造函数设为 private。
• C++11 方式：用 final 关键字修饰基类。

class Base final {
public:
    void func() { cout << "Base::func" << endl; }
};
// class Derive : public Base {}; // 编译报错

五、继承的特殊场景：友元、静态成员与多继承

5.1 友元不能继承

基类的友元无法访问派生类的 private/protected 成员。

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 _stuNum = 1001;
};

void Display(const Person& p, const Student& s) {
    cout << p._name << endl;
    // cout << s._stuNum << endl; // 编译报错
}

5.2 静态成员共享

基类的静态成员在整个继承体系中只有一份实例。

class Person {
public:
    static int _count;
protected:
    string _name;
};
int Person::_count = 0;

class Student : public Person {};
class Teacher : public Person {};

int main() {
    Person p; Student s; Teacher t;
    p._count++; s._count++; t._count++;
    cout << Person::_count << endl; // 输出 3
    return 0;
}

5.3 多继承与菱形问题

单继承：一个派生类只有一个直接基类。 多继承：一个派生类有多个直接基类，可能引发'菱形继承'问题。

5.3.1 菱形继承的坑

Assistant 同时继承 Student 和 Teacher，而两者都继承 Person，导致 Assistant 中有两份 Person 成员，造成数据冗余和二义性。

5.3.2 解决方案：虚继承

在间接基类继承处加 virtual 关键字。

class Person { public: string _name; };
class Student : virtual public Person { protected: int _num; };
class Teacher : virtual public Person { protected: int _id; };
class Assistant : public Student, public Teacher { protected: string _major; };

int main() {
    Assistant a;
    a._name = "peter"; // 正常访问，无二义性
    return 0;
}

注意：虚继承增加性能开销，不建议设计菱形结构。

六、继承 vs 组合：代码复用的选择艺术

6.1 核心区别：is-a 与 has-a

• 继承（is-a）：派生类是基类的一种（如'宝马是车'）。白箱复用，耦合度高。
• 组合（has-a）：一个类包含另一个类的对象（如'车有轮胎'）。黑箱复用，耦合度低。

6.2 实例对比

// 场景 1：车和轮胎（has-a，用组合）
class Tire { protected: string _brand = "米其林"; int _size = 17; };
class Car { protected: string _color = "白色"; Tire _t1, _t2, _t3, _t4; };

// 场景 2：宝马和车（is-a，用继承）
class BMW : public Car { public: void Drive() { cout << "宝马：操控好" << endl; } };

// 场景 3：栈和 vector（优先组合）
class Stack2 {
private:
    vector<int> _v;
public:
    void push(int x) { _v.push_back(x); }
    int top() { return _v.back(); }
};

6.3 最佳实践

当类之间明确是'is-a'关系且需要多态时，用继承。当类之间是'has-a'关系或关系模糊时，优先用组合。

七、总结：继承的核心要点

1. 本质：类层次的代码复用。
2. 访问控制：基类 private 成员不可见，优先用 public 继承。
3. 隐藏规则：同名成员触发隐藏，需显式加作用域。
4. 默认成员函数：构造/拷贝/赋值需调用基类对应函数，析构自动调用基类析构。
5. 特殊场景：友元不继承，静态成员共享，菱形继承用虚继承解决。
6. 复用选择：优先组合（低耦合），适当继承（is-a 或多态）。

掌握继承的细节和陷阱，才能写出更优雅、更可维护的代码。