C++ 继承的核心要点与实战案例

输出：

张三 正在吃饭
张三 正在睡觉
张三 正在学习，学号：2024001

派生类对象 s 直接就能用基类的 name、age、eat() 和 sleep()，同时还能访问自己的 studentID 和 study()。

三种继承方式的区别

继承方式影响的是基类成员在派生类中变成什么访问权限，不会突破原有的限制。核心规则这张表说得很清楚：

无论哪种继承，基类的 private 成员永远是派生类直接碰不到的，只能通过基类提供的 public 或 protected 接口间接操作。

实际项目里，public 继承占了绝大多数情况，protected 和 private 继承只在少数需要刻意隐藏实现细节的场合才会用到。

下面分别看看三种继承方式的效果。

public 继承

class Base {
public:
    int pub;
protected:
    int pro;
private:
    int pri;
};

class PubDerived : public Base {
public:
    void show() {
        pub = 10;   // OK，仍然是 public
        pro = 20;   // OK，变成 protected
        // pri = 30; // 错误：private 不可访问
    }
};

int main() {
    PubDerived pd;
    pd.pub = 100;   // OK，类外可访问 public 成员
    // pd.pro = 200; // 错误：protected 成员类外不可访问
    return 0;
}

protected 继承

class ProDerived : protected Base {
public:
    void show() {
        pub = 10;   // OK，变成 protected
        pro = 20;   // OK，仍是 protected
        // pri = 30; // 错误
    }
};

int main() {
    ProDerived prd;
    // prd.pub = 100; // 错误：pub 现在是 protected，类外不能访问
    return 0;
}

private 继承

class PriDerived : private Base {
public:
    void show() {
        pub = 10;   // OK，变成 private
        pro = 20;   // OK，变成 private
        // pri = 30; // 错误
    }
};

int main() {
    PriDerived prd;
    // prd.pub = 100; // 错误：pub 现在是 private，类外不能访问
    return 0;
}

构造与析构的顺序

派生类对象创建和销毁时，构造和析构的调用顺序是固定的：先构造基类部分，再构造派生类部分；析构正好相反，先析构派生类，再析构基类。可以简单记成'构造先基后派，析构先派后基'。

一段简单的测试代码就能看到这个顺序：

#include <iostream>
using namespace std;

class Person {
public:
    Person() { cout << "Person 基类构造函数被调用" << endl; }
    ~Person() { cout << "Person 基类析构函数被调用" << endl; }
};

class Student : public Person {
public:
    Student() { cout << "Student 派生类构造函数被调用" << endl; }
    ~Student() { cout << "Student 派生类析构函数被调用" << endl; }
};

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

输出：

Person 基类构造函数被调用
Student 派生类构造函数被调用
Student 派生类析构函数被调用
Person 基类析构函数被调用

如果基类没有默认构造函数（比如只定义了带参数的构造函数），派生类就必须在初始化列表里显式调用基类的构造，否则编译不过。

class Person {
public:
    string name;
    int age;
    Person(string n, int a) : name(n), age(a) {
        cout << "Person 带参构造函数被调用" << endl;
    }
};

class Student : public Person {
public:
    int studentID;
    Student(string n, int a, int id) : Person(n, a), studentID(id) {
        cout << "Student 带参构造函数被调用" << endl;
    }
    void show() {
        cout << "姓名：" << name << " 年龄：" << age << " 学号：" << studentID << endl;
    }
};

int main() {
    Student s("李四", 20, 2024002);
    s.show();
    return 0;
}

一个稍微完整点的例子：员工管理

假定要写一个简单的员工管理系统，有普通员工 Employee 和经理 Manager。经理也是员工，所以可以让 Manager 公有继承 Employee，然后加上管理部门和 manage 方法。同时经理的工作行为可能与普通员工不同，可以重写 work 方法。

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

class Employee {
protected:
    string name;
    int empID;
    double salary;
public:
    Employee(string n, int id, double sal) : name(n), empID(id), salary(sal) {
        cout << "Employee 构造函数被调用" << endl;
    }
    void work() {
        cout << "员工 " << name << "（工号：" << empID << "）正在工作，月薪：" << salary << endl;
    }
    ~Employee() {
        cout << "Employee 析构函数被调用" << endl;
    }
};

class Manager : public Employee {
private:
    string department;
public:
    Manager(string n, int id, double sal, string dep)
        : Employee(n, id, sal), department(dep) {
        cout << "Manager 构造函数被调用" << endl;
    }
    void manage() {
        cout << "经理 " << name << " 管理 " << department << " 部门" << endl;
    }
    // 重写 work，经理的工作描述不同
    void work() {
        cout << "经理 " << name << "（工号：" << empID << "）正在管理工作，月薪：" << salary << endl;
    }
    ~Manager() {
        cout << "Manager 析构函数被调用" << endl;
    }
};

int main() {
    Employee emp("王五", 1001, 5000.0);
    emp.work();
    cout << "-------------------------" << endl;
    Manager mgr("赵六", 9001, 15000.0, "技术部");
    mgr.work();
    mgr.manage();
    return 0;
}

运行结果里可以清楚看到构造和析构的顺序：创建 mgr 时先执行 Employee 构造然后 Manager 构造；销毁时则先 Manager 析构再 Employee 析构。注意 emp 的析构在 mgr 之前还是之后？因为 emp 先创建，后销毁（栈上后进先出），所以会先看到 mgr 的析构，最后是 emp 的析构。

几个常见坑和解决办法

1. 派生类里想用基类的 private 成员怎么办？

最直接的办法是把那些成员改成 protected，这样派生类就能直接访问了。如果不想改源代码，也可以在基类里提供 public 或 protected 的 getter/setter 接口。

2. 基类没有默认构造函数，派生类直接报错

派生类的构造函数初始化列表里显式调用基类有参构造就行，前面已经演示过。

3. 多重继承的命名冲突

C++ 允许多重继承，但两个基类有同名成员时会出二义性。解决办法是用作用域解析符 :: 明确指出调用哪个基类的版本：

class A {
public:
    void func() { cout << "A 的 func" << endl; }
};
class B {
public:
    void func() { cout << "B 的 func" << endl; }
};
class C : public A, public B {};

int main() {
    C c;
    c.A::func();
    c.B::func();
    return 0;
}

多重继承容易让代码变得难以维护，实际用的时候最好多考虑是否可以用组合或其他设计代替。

小结

继承是 C++ 里最基础的复用机制，核心就几点：

• 派生类继承基类的成员，可以添加新成员，也可以重写已有行为。
• public 继承最常用，权限转换规则是'不能提升，只能不变或限制'。
• 构造析构顺序固定：先基类后派生（构造），先派生后基类（析构）。基类无默认构造时，派生类必须显式调用。
• 多重继承要谨慎，必要时用 :: 解决冲突。

理解这些基础，后面再去用虚函数和多态时就不会觉得搞不清构造析构到底怎么跑了。