C++继承与多态：构建灵活的类层次结构

继承：代码重用的强大工具

欢迎回到C++面向对象编程的深度探索！在前一篇文章中，我们学习了类和对象的基础知识，今天我们将揭开面向对象编程最强大的两个特性——继承和多态的神秘面纱。继承就像生物学中的遗传机制，允许新类基于现有类创建，继承其特性并添加新功能。

想象你正在开发一个图形绘制程序。所有图形（圆形、矩形、三角形等）都有共同属性（如颜色、位置）和行为（如绘制、移动）。通过继承，你可以创建一个基础Shape类包含这些共性，然后派生特定图形类继承这些特性并添加自己的独特功能。这种方式不仅减少了代码重复，还使程序结构更加清晰和易于维护。

继承的基本概念与语法

基类与派生类

在继承关系中，被继承的类称为基类（或父类），新创建的类称为派生类（或子类）。派生类继承基类的成员，并可以添加新成员或修改继承的成员行为。

继承语法

class 派生类名 : 访问说明符 基类名 {// 派生类成员
};

访问说明符可以是public、protected或private，决定了基类成员在派生类中的访问级别。

一个简单的继承示例

#include <iostream>
#include <string>// 基类
class Animal {
protected:std::string name;int age;public:Animal(const std::string &n, int a) : name(n), age(a) {}void eat() const {std::cout << name << "正在吃东西..." << std::endl;}void sleep() const {std::cout << name << "正在睡觉..." << std::endl;}
};// 派生类
class Dog : public Animal {
private:std::string breed;public:Dog(const std::string &n, int a, const std::string &b) : Animal(n, a), breed(b) {}void bark() const {std::cout << name << "（品种：" << breed << "）: 汪汪！" << std::endl;}void displayInfo() const {std::cout << "狗狗信息 - 名字: " << name << ", 年龄: " << age << "岁, 品种: " << breed << std::endl;}
};int main() {Dog myDog("Buddy", 3, "金毛寻回犬");myDog.displayInfo();myDog.eat();    // 继承自Animal的方法myDog.sleep();  // 继承自Animal的方法myDog.bark();   // Dog特有的方法return 0;
}

不同类型的继承

C++支持三种继承方式，影响基类成员在派生类中的访问权限：

1. 公有继承（public）

最常用的继承方式，保持基类成员的访问权限不变：

基类的public成员 → 派生类的public成员
基类的protected成员 → 派生类的protected成员
基类的private成员 → 不可直接访问

class Base {
public:int publicMember;
protected:int protectedMember;
private:int privateMember;
};class Derived : public Base {// publicMember仍然是public// protectedMember仍然是protected// privateMember不可访问
};

2. 保护继承（protected）

将基类的public和protected成员都变为派生类的protected成员：

class Derived : protected Base {// publicMember变为protected// protectedMember仍然是protected// privateMember不可访问
};

3. 私有继承（private）

将基类的public和protected成员都变为派生类的private成员：

class Derived : private Base {// publicMember变为private// protectedMember变为private// privateMember不可访问
};

注意：在实际开发中，公有继承最常用，其他两种继承方式较少使用。

多继承与菱形问题

C++支持多继承，即一个派生类可以从多个基类继承：

#include <iostream>class Worker {
public:void work() {std::cout << "工作中..." << std::endl;}
};class Student {
public:void study() {std::cout << "学习中..." << std::endl;}
};// 多继承
class WorkingStudent : public Worker, public Student {
public:void busyDay() {work();study();std::cout << "真是忙碌的一天！" << std::endl;}
};int main() {WorkingStudent ws;ws.busyDay();return 0;
}

菱形继承问题

当多个基类继承自同一个祖先类时，会导致派生类中包含多个祖先类子对象，造成二义性：

class A {
public:int value;
};class B : public A {};
class C : public A {};class D : public B, public C {};

此时，D对象包含两个A子对象，访问value会产生二义性。解决方案是使用虚继承：

class B : virtual public A {};
class C : virtual public A {};class D : public B, public C {};

虚继承确保派生类中只保留一份虚基类子对象。

多态：面向对象的精髓

多态（Polymorphism）允许我们通过基类指针或引用调用派生类的实现，这是面向对象编程最强大的特性之一。C++通过虚函数实现运行时多态。

虚函数与重写

#include <iostream>
#include <vector>class Shape {
public:// 虚函数virtual void draw() const {std::cout << "绘制一个形状" << std::endl;}// 虚析构函数（重要！）virtual ~Shape() {}
};class Circle : public Shape {
public:// 重写基类虚函数void draw() const override {std::cout << "绘制一个圆形" << std::endl;}
};class Rectangle : public Shape {
public:void draw() const override {std::cout << "绘制一个矩形" << std::endl;}
};class Triangle : public Shape {
public:void draw() const override {std::cout << "绘制一个三角形" << std::endl;}
};int main() {std::vector<Shape*> shapes;shapes.push_back(new Circle());shapes.push_back(new Rectangle());shapes.push_back(new Triangle());for (const auto &shape : shapes) {shape->draw(); // 多态调用}// 释放内存for (const auto &shape : shapes) {delete shape;}return 0;
}

关键点：

使用virtual关键字声明虚函数
派生类使用override关键字明确表示重写虚函数
基类析构函数应该声明为virtual，确保正确调用派生类析构函数
通过基类指针或引用调用虚函数时，实际调用的是对象类型的实现

纯虚函数与抽象类

纯虚函数是没有实现的虚函数，使类成为抽象类（不能实例化）：

class AbstractShape {
public:// 纯虚函数virtual double area() const = 0;virtual ~AbstractShape() {}
};class ConcreteCircle : public AbstractShape {
private:double radius;public:ConcreteCircle(double r) : radius(r) {}double area() const override {return 3.14159 * radius * radius;}
};int main() {// AbstractShape shape; // 错误：不能实例化抽象类ConcreteCircle circle(5.0);std::cout << "圆面积: " << circle.area() << std::endl;return 0;
}

抽象类用于定义接口，强制派生类实现特定功能。

运行时类型识别（RTTI）

C++提供了typeid和dynamic_cast用于运行时类型识别：

#include <iostream>
#include <typeinfo>class Base {
public:virtual ~Base() {}
};class Derived : public Base {};void identify(Base *ptr) {// 使用typeid获取类型信息std::cout << "指针指向的对象类型: " << typeid(*ptr).name() << std::endl;// 使用dynamic_cast尝试向下转型if (Derived *d = dynamic_cast<Derived*>(ptr)) {std::cout << "成功转换为Derived指针" << std::endl;} else {std::cout << "转换失败" << std::endl;}
}int main() {Base *b1 = new Base();Base *b2 = new Derived();identify(b1);identify(b2);delete b1;delete b2;return 0;
}

注意：RTTI会带来少量性能开销，应谨慎使用。

实践项目：员工管理系统

让我们构建一个完整的员工管理系统，展示继承和多态的实际应用：

#include <iostream>
#include <string>
#include <vector>
#include <memory>class Employee {
protected:std::string name;int id;double salary;public:Employee(const std::string &n, int i, double s) : name(n), id(i), salary(s) {}virtual ~Employee() {}virtual void work() const {std::cout << name << " (ID: " << id << ") 正在执行一般工作任务" << std::endl;}virtual void calculateSalary() {std::cout << name << " 的基本工资: " << salary << std::endl;}virtual void displayInfo() const {std::cout << "员工信息 - 姓名: " << name << ", ID: " << id << ", 基本工资: " << salary << std::endl;}
};class Manager : public Employee {
private:double bonus;public:Manager(const std::string &n, int i, double s, double b) : Employee(n, i, s), bonus(b) {}void work() const override {std::cout << name << " (ID: " << id << ") 正在管理团队" << std::endl;}void calculateSalary() override {Employee::calculateSalary();std::cout << "奖金: " << bonus << ", 总工资: " << (salary + bonus) << std::endl;}void conductMeeting() const {std::cout << name << " 正在主持会议" << std::endl;}void displayInfo() const override {Employee::displayInfo();std::cout << "职位: 经理, 奖金: " << bonus << std::endl;}
};class Developer : public Employee {
private:std::string programmingLanguage;public:Developer(const std::string &n, int i, double s, const std::string &lang) : Employee(n, i, s), programmingLanguage(lang) {}void work() const override {std::cout << name << " (ID: " << id << ") 正在用" << programmingLanguage << "编写代码" << std::endl;}void debugCode() const {std::cout << name << " 正在调试" << programmingLanguage << "代码" << std::endl;}void displayInfo() const override {Employee::displayInfo();std::cout << "职位: 开发人员, 编程语言: " << programmingLanguage << std::endl;}
};class Intern : public Employee {
private:int internshipDuration; // 实习周数public:Intern(const std::string &n, int i, double s, int duration) : Employee(n, i, s), internshipDuration(duration) {}void work() const override {std::cout << name << " (ID: " << id << ") 正在学习并协助完成任务" << std::endl;}void attendTraining() const {std::cout << name << " 正在参加培训" << std::endl;}void displayInfo() const override {Employee::displayInfo();std::cout << "职位: 实习生, 实习时长: " << internshipDuration << "周" << std::endl;}
};int main() {std::vector<std::unique_ptr<Employee>> employees;// 创建不同类型的员工employees.emplace_back(new Manager("张经理", 101, 15000, 5000));employees.emplace_back(new Developer("李开发", 102, 12000, "C++"));employees.emplace_back(new Developer("王开发", 103, 13000, "Python"));employees.emplace_back(new Intern("赵实习生", 104, 3000, 12));// 多态处理员工for (const auto &emp : employees) {emp->displayInfo();emp->work();emp->calculateSalary();// 尝试向下转型if (auto mgr = dynamic_cast<Manager*>(emp.get())) {mgr->conductMeeting();} else if (auto dev = dynamic_cast<Developer*>(emp.get())) {dev->debugCode();} else if (auto intern = dynamic_cast<Intern*>(emp.get())) {intern->attendTraining();}std::cout << "---------------------" << std::endl;}return 0;
}

这个示例展示了：