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

运行结果如下：

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

三种继承方式的权限控制

继承方式直接决定了基类成员在派生类中的可见性。记住一个原则：继承方式不会提升成员的访问权限，只会限制或保持原有权限。

权限对比表

核心注意点：

1. 基类的 private 成员在派生类中始终不可直接访问，只能通过基类的 public 或 protected 方法间接访问。
2. 实际开发中，public 继承是最常用的方式，因为它最能体现'是一个'的关系（is-a relationship）。

代码演示

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

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

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

输出结果会显示基类构造在前，析构在后。

带参数的构造函数

当基类只有带参数的构造函数时，派生类必须在初始化列表中显式调用基类的构造函数。

#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。Manager 继承 Employee，并增加部门属性和管理方法。

完整代码

#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 成员

解决：将基类需要被访问的成员设为 protected，或在基类提供 public 的 get/set 方法。

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

总结

继承是 C++ 面向对象编程的基石。通过理解三种继承方式的权限变化，掌握构造与析构的顺序，我们就能构建出结构清晰、复用性强的代码。在实际开发中，合理使用继承，配合虚函数多态，能极大提升系统的可维护性。