C++ 继承：面向对象代码复用的核心机制

运行结果如下：

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

三种继承方式的访问权限控制

继承方式直接影响基类成员在派生类中的访问权限。核心规则是：继承方式不会提升成员的访问权限，只会限制或保持原有权限。

权限对比表

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

注意几点：

1. 基类的 private 成员在派生类中始终不可直接访问，只能通过基类的 public 或 protected 方法间接访问。
2. 继承方式的限制作用是单向的，派生类无法突破基类的权限限制。
3. 实际开发中，public 继承是最常用的方式，protected 和 private 继承仅在特定场景使用。

代码演示

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

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

3. 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 两类角色。

1. 基类 Employee：属性（姓名、工号、工资），方法（工作 work()）。
2. 派生类 Manager：公有继承 Employee，新增属性（部门），新增方法（管理 manage()）。
3. 要求：通过构造函数初始化所有属性，保证数据完整性。

完整代码实现

#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 析构函数被调用

常见问题与解决方案

问题 1：派生类无法访问基类 private 成员

解决方案：

1. 将基类需要被派生类访问的成员设置为 protected 权限。
2. 在基类中提供 public 的 get/set 方法，让派生类间接访问 private 成员。

问题 2：基类无默认构造函数，派生类编译报错

解决方案：在派生类的构造函数初始化列表中，显式调用基类的带参数构造函数。

问题 3：多重继承导致的二义性（钻石问题）

多重继承是指一个派生类同时继承多个基类，容易出现同名成员冲突的问题。

解决方案：使用作用域解析符 :: 明确指定要访问的基类成员。

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

总结

• 继承的核心是代码复用与功能扩展，派生类可以继承基类的属性和方法，并新增自己的专属内容。
• 三种继承方式中，public 继承最常用，其权限规则是'不提升、只限制'。
• 继承中的构造顺序是先基后派，析构顺序是先派后基，带参构造需要在初始化列表显式调用。
• 多重继承容易引发二义性，可通过作用域解析符解决，实际开发中应谨慎使用多重继承。