C++ 中的继承（Inheritance）

十年一梦实验室

已于 2025-03-12 16:13:06 修改

阅读量655

点赞数 21

文章标签： c++

于 2025-03-12 16:04:16 首次发布

本文链接：https://blog.youkuaiyun.com/cxyhjl/article/details/146207737

版权

讲解：C++ 中的继承（Inheritance）

继承（Inheritance）是面向对象编程（OOP）中的核心特性之一，它允许一个类（子类或派生类）从另一个类（基类或父类）继承其数据成员和成员函数。在 C++ 中，继承的使用需谨慎，通常建议**优先使用组合（composition）**而非继承。本文将从定义、用途、优点、缺点及使用建议等方面详细讲解 C++ 中的继承。

定义

当子类继承基类时，子类包含了基类的所有数据成员和操作（成员函数）的定义。C++ 中的继承主要用于以下两种场合：

实现继承（Implementation Inheritance）
子类直接继承基类的实现代码，从而重用基类的功能。
接口继承（Interface Inheritance）
子类仅继承基类的方法名称（通常通过纯虚函数实现），而不继承具体实现，用于定义接口。

优点

实现继承的优点：
- 代码重用：通过直接使用基类的代码，减少了重复编写代码的工作量。
- 编译时检查：继承关系在编译时声明，编译器可以理解操作并检测错误，确保类型安全。
接口继承的优点：
- 功能增强：通过接口继承，可以为类扩展特定的 API 功能。
- 错误检测：如果子类未实现接口中定义的必要方法，编译器会报错，便于调试。

缺点

实现继承的缺点：
- 代码分散：子类的实现逻辑分布在基类和子类之间，使得理解和维护变得困难。
- 不可重写非虚函数：子类无法修改基类的非虚函数实现，限制了灵活性。
- 耦合性增加：基类的数据成员会影响子类的物理布局（内存结构），可能导致紧耦合。
接口继承的缺点：
- 如果使用不当，可能导致接口设计不清晰，增加代码复杂度。

使用建议与结论

在 C++ 中，合理使用继承可以提高代码质量，但过度或不当使用会带来问题。以下是具体建议：

优先使用组合（Composition）
- 组合是指将一个类作为另一个类的成员，通常比继承更灵活、更易于维护。
- GoF（《设计模式》作者）反复强调，组合优于继承，因为它避免了继承带来的复杂性和耦合。
- 示例：如果 Car 有一个 Engine，应使用组合而非继承。
只在“是一个”（is-a）关系时使用继承
- 继承适用于表示“是一个”关系的场景，即子类是基类的一种具体类型。
  - 例如，Dog 是 Animal 的一种，可以使用继承。
- 对于“有一个”（has-a）关系，应使用组合。
  - 例如，Car 有一个 Engine，不应使用继承。
所有继承必须是公共的（public）
- C++ 支持 public、protected 和 private 继承，但建议只使用公共继承。
- 如果需要私有继承的效果，应改为使用组合（将基类作为成员），这样更直观且避免隐藏基类接口。
  - 私有继承的替代示例：
```
class Base { /* ... */ };
class Derived {
private:
    Base base;  // 组合替代私有继承
public:
    void useBase() { base.someMethod(); }
};
```
不要过多使用实现继承
- 实现继承虽然能重用代码，但可能导致代码结构复杂、难以调试。
- 对于代码重用，组合通常是更优的选择。
必要时令析构函数为虚函数
- 如果一个类设计为被继承（即包含虚函数），其析构函数必须是虚函数。
- 这是为了确保通过基类指针删除派生类对象时，能正确调用派生类的析构函数，避免内存泄漏。
  - 示例：
```
class Base {
public:
    virtual ~Base() {}  // 虚析构函数
};
class Derived : public Base {};
```

示例代码

公共继承（is-a 关系）

#include <iostream>
class Animal {
public:
    virtual void makeSound() const = 0;  // 纯虚函数，接口继承
    virtual ~Animal() {}  // 虚析构函数
};

class Dog : public Animal {
public:
    void makeSound() const override { std::cout << "Woof!" << std::endl; }
};

int main() {
    Animal* dog = new Dog();
    dog->makeSound();  // 输出 "Woof!"
    delete dog;  // 正确调用 Dog 的析构函数
    return 0;
}

Dog 是 Animal 的一种，继承并实现了 makeSound 接口。

组合（has-a 关系）

#include <iostream>
class Engine {
public:
    void start() { std::cout << "Engine started" << std::endl; }
};

class Car {
private:
    Engine engine;  // 组合
public:
    void start() { engine.start(); }
};

int main() {
    Car car;
    car.start();  // 输出 "Engine started"
    return 0;
}

Car 有一个 Engine，通过组合实现功能。

总结

继承：适用于“是一个”关系，建议只使用公共继承，避免过度依赖实现继承。
组合：优先选择，特别是在“有一个”关系时，更灵活且易于维护。
虚析构函数：如果类有虚函数，析构函数应为虚函数。
通过遵循这些原则，可以使 C++ 代码更清晰、健壮，并减少继承带来的潜在问题。

下面我将通过一个具体的例子来讲解 C++ 中��接口继承（Interface Inheritance）。在接口继承中，子类仅继承基类的方法名称（通常通过纯虚函数实现），而不继承具体实现。这种方式常用于定义抽象接口，强制要求子类提供具体的实现。

示例：接口继承

场景

假设我们要设计一个系统来表示不同类型的图形（Shape），每种图形都可以计算面积（area）和绘制（draw）。我们希望定义一个通用的接口 Shape，然后让具体图形（如 Circle 和 Rectangle）继承这个接口并实现各自的功能。

代码实现

#include <iostream>
#include <cmath>

// 基类：抽象接口 Shape，使用纯虚函数定义接口
class Shape {
public:
    // 纯虚函数：计算面积
    virtual double area() const = 0;

    // 纯虚函数：绘制图形
    virtual void draw() const = 0;

    // 虚析构函数，确保派生类对象正确析构
    virtual ~Shape() {}
};

// 派生类：圆形 (Circle)
class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // 实现接口：计算圆的面积
    double area() const override {
        return M_PI * radius * radius;
    }

    // 实现接口：绘制圆
    void draw() const override {
        std::cout << "Drawing a circle with radius " << radius << std::endl;
    }
};

// 派生类：矩形 (Rectangle)
class Rectangle : public Shape {
private:
    double width;
    double height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    // 实现接口：计算矩形的面积
    double area() const override {
        return width * height;
    }

    // 实现接口：绘制矩形
    void draw() const override {
        std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl;
    }
};

// 测试代码
int main() {
    // 通过基类指针调用接口
    Shape* shapes[] = { new Circle(5.0), new Rectangle(4.0, 6.0) };

    for (int i = 0; i < 2; ++i) {
        std::cout << "Area: " << shapes[i]->area() << std::endl;
        shapes[i]->draw();
        std::cout << "----------" << std::endl;
    }

    // 清理内存
    for (int i = 0; i < 2; ++i) {
        delete shapes[i];
    }

    return 0;
}

输出结果

Area: 78.5398
Drawing a circle with radius 5
----------
Area: 24
Drawing a rectangle with width 4 and height 6
----------

代码讲解

基类 Shape（接口定义）
- Shape 是一个抽象基类，使用纯虚函数（= 0）定义了两个方法：area() 和 draw()。
- 纯虚函数没有实现，仅提供方法名称和签名，强制要求派生类实现这些方法。
- virtual ~Shape() {} 是一个虚析构函数，确保通过基类指针删除派生类对象时能正确调用派生类的析构函数。
- 因为包含纯虚函数，Shape 无法实例化，只能作为接口被继承。
派生类 Circle 和 Rectangle
- Circle 和 Rectangle 通过公共继承（public Shape）继承了 Shape 接口。
- 它们分别实现了 area() 和 draw() 方法，使用 override 关键字明确表示覆盖基类的虚函数。
- 每个派生类根据自身特性提供了具体的实现：
  - Circle 使用公式 π * r² 计算面积。
  - Rectangle 使用公式 width * height 计算面积。
接口继承的特点
- 仅继承方法名称：Shape 只定义了 area() 和 draw() 的接口，没有任何具体实现。实现完全由子类提供。
- 多态性：通过基类指针 Shape* 调用方法时，会动态绑定到具体的派生类实现（如 Circle::area() 或 Rectangle::area()）。
- 强制实现：如果派生��没有实现所有纯虚函数，编译器会报错。例如，若 Circle 未实现 area()，则无法编译。
测试代码
- 在 main 函数中，我们创建了一个 Shape* 数组，存储不同类型的图形对象。
- 通过基类指针调用 area() 和 draw()，展示了接口继承的多态性。
- 最后通过 delete 清理内存，虚析构函数确保资源正确释放。

接口继承的优势

抽象性：Shape 定义了一个通用的图形接口，适用于所有具体图形类型。
灵活性：可以轻松添加新的图形类型（如 Triangle），只需继承 Shape 并实现接口。
类型安全：编译器会检查是否所有纯虚函数都被实现，避免运行时错误。

与实现继承的对比

如果 Shape 提供了 area() 的默认实现（如返回 0），那就是实现继承（Implementation Inheritance）。但在接口继承中，基类不提供任何实现，完全依赖子类。

扩展

如果需要添加一个新的图形类型，例如三角形（Triangle），只需定义：

class Triangle : public Shape {
private:
    double base;
    double height;
public:
    Triangle(double b, double h) : base(b), height(h) {}
    double area() const override { return 0.5 * base * height; }
    void draw() const override { std::cout << "Drawing a triangle" << std::endl; }
};