C++ 继承实战：从语法细到员工管理系统

输出：

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

三种继承方式：访问权限到底怎么变

继承方式影响基类成员在派生类里的可见性，但有一条基本规则：继承方式只会限制或保持原有权限，不会提升。具体看这张表：

| 基类成员权限 | public 继承 | protected 继承 | private 继承 | | --- | --- | --- | | public | public | protected | private | | protected | protected | protected | private | | private | 不可访问 | 不可访问 | 不可访问 |

几点实用提醒：

1. 基类的 private 成员，派生类永远不能直接碰，只能靠基类的 public/protected 方法间接访问。
2. 继承方式的限制是单向的，派生类没办法突破基类设的权限。
3. 绝大多数场景下，public 继承就够了，protected 和 private 继承只在极少数设计里出现。

下面用代码演示三种继承的效果。

public 继承

#include <iostream>
using namespace std;

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

// 公有继承
class PubDerived : public Base {
public:
    void show() {
        pub = 10;      // 合法：public 继承后仍为 public
        pro = 20;      // 合法：public 继承后为 protected
        // pri = 30;   // 非法：基类 private 成员不可访问
    }
};

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

protected 继承

class ProDerived : protected Base {
public:
    void show() {
        pub = 10;      // 合法：protected 继承后为 protected
        pro = 20;      // 合法：protected 继承后仍为 protected
        // pri = 30;   // 非法：基类 private 成员不可访问
    }
};

int main() {
    ProDerived prd;
    // prd.pub = 100; // 非法：protected 继承后 pub 变为 protected，类外不可访问
    return 0;
}

private 继承

class PriDerived : private Base {
public:
    void show() {
        pub = 10;      // 合法：private 继承后为 private
        pro = 20;      // 合法：private 继承后为 private
        // pri = 30;   // 非法：基类 private 成员不可访问
    }
};

int main() {
    PriDerived prd;
    // prd.pub = 100; // 非法：private 继承后 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
    Student s;
    // 函数结束时对象销毁，自动调用析构函数
    return 0;
}

运行结果：

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

如果基类只有带参数的构造函数怎么办？派生类必须在初始化列表里显式调用基类构造，不然编译报错。

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

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，经理多一个部门属性和管理方法。

• 基类 Employee：姓名、工号、工资，还有 work()。
• 派生类 Manager：公有继承自 Employee，新增 department，改写 work()，再加 manage()。
• 所有属性通过构造函数初始化，保证数据完整。

完整代码：

#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();       // 调用重写后的 work 方法
    mgr.manage();     // 调用新增的 manage 方法

    return 0;
}

输出：

Employee 构造函数被调用
员工 王五（工号：1001）正在工作，月薪：5000
-------------------------
Employee 构造函数被调用
Manager 构造函数被调用
经理 赵六（工号：9001）正在管理工作，月薪：15000
经理 赵六 管理 技术部 部门
Manager 析构函数被调用
Employee 析构函数被调用
Employee 析构函数被调用

常见坑与解决思路

派生类访问不到基类的 private 成员

两种办法：

1. 把基类里要被派生类访问的成员改成 protected。
2. 在基类提供 public 的 get/set 接口。

基类没有默认构造函数，派生类编译报错

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

多重继承的二义性（钻石问题）

一个派生类同时继承多个基类，如果两个基类有同名成员，直接调用就会冲突。

解决：用作用域解析符 :: 明确指定用哪个基类的版本。

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(); // 明确调用 A 类的 func 方法
    c.B::func(); // 明确调用 B 类的 func 方法
    return 0;
}

继承解决的就是代码复用和扩展的问题，但用起来得留心权限控制、构造析构顺序这些细节。多重继承更是容易出坑，非必要不推荐。