异常教程

C++ 继承（手把手讲解）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在面向对象编程（OOP）中，C++ 继承是实现代码复用和构建灵活类层次结构的核心机制。它允许开发者通过“继承”关系，将已有类的功能和属性传递给新的子类，从而避免重复代码的编写。无论是构建复杂的软件系统，还是设计可扩展的框架，C++ 继承都扮演着不可或缺的角色。本文将从基础概念到高级应用，结合实际案例，深入浅出地解析这一主题，帮助读者掌握其核心原理与最佳实践。

一、继承的基本概念与语法

1.1 什么是继承？

继承是类之间的一种“父子关系”。通过继承，派生类（子类）可以直接使用基类（父类）的成员变量和成员函数，同时还可以添加新的成员或覆盖已有成员。这种设计类似于现实中的“家族树”：子类继承了父类的“基因”，但也可以发展出独特的特征。

例如，假设有一个Animal类，它包含name和age两个成员变量，以及makeSound()函数。如果创建一个Dog类作为Animal的子类，那么Dog会自动拥有name、age和makeSound()，同时可以添加bark()等独有的功能。

class Animal {  
public:  
    std::string name;  
    int age;  
    void makeSound() {  
        std::cout << "Animal makes a sound!" << std::endl;  
    }  
};  

class Dog : public Animal {  // 使用 public 继承  
public:  
    void bark() {  
        std::cout << name << " barks!" << std::endl;  
    }  
};

1.2 继承的语法与访问权限

在 C++ 中，继承通过 class Derived : <访问权限> Base 的语法实现。访问权限有三种：

  • public：基类的公有成员在派生类中保持公有，保护成员变为保护。
  • protected：基类的公有和保护成员在派生类中变为保护。
  • private：基类的公有和保护成员在派生类中变为私有。

注意：派生类默认继承方式为 private，因此建议显式指定访问权限以避免歧义。

二、继承的实现细节与注意事项

2.1 构造函数与析构函数的行为

当创建派生类对象时，C++ 会先调用基类的构造函数，再调用派生类的构造函数；销毁对象时则相反，先调用派生类析构函数，再调用基类析构函数。

例如，若基类 Animal 有构造函数：

class Animal {  
public:  
    Animal(std::string n, int a) : name(n), age(a) {}  
    // ... 其他成员  
};

则派生类 Dog 必须显式调用基类构造函数：

class Dog : public Animal {  
public:  
    Dog(std::string n, int a) : Animal(n, a) {}  // 显式初始化基类  
    // ... 其他成员  
};

2.2 成员访问权限与继承方向

继承方向和访问权限共同决定了子类对基类成员的可见性。以下表格总结了不同组合的规则：

继承方式基类成员类型派生类可见性
publicpublicpublic
publicprotectedprotected
publicprivate不可见
protectedpublicprotected
protectedprotectedprotected
protectedprivate不可见
privatepublicprivate
privateprotectedprivate
privateprivate不可见

三、多态与虚函数：继承的动态特性

3.1 多态的定义与作用

多态（Polymorphism）是面向对象编程的四大特性之一，指“同一接口，多种实现”。通过继承和虚函数，派生类可以覆盖基类的方法，而程序在运行时根据对象的实际类型调用正确的函数。

例如，基类 Shape 可以定义一个虚函数 area()，而派生类 Circle 和 Rectangle 分别实现自己的计算逻辑：

class Shape {  
public:  
    virtual double area() {  // 虚函数标记多态  
        return 0.0;  
    }  
};  

class Circle : public Shape {  
private:  
    double radius;  
public:  
    double area() override {  // 覆盖虚函数  
        return 3.14 * radius * radius;  
    }  
};

3.2 虚函数与纯虚函数

  • 虚函数（Virtual Function）：通过 virtual 关键字声明，允许派生类覆盖其实现。
  • 纯虚函数（Pure Virtual Function）：形式为 virtual returnType functionName() = 0;，强制派生类必须实现该函数。包含纯虚函数的类称为抽象类，不能直接实例化。

案例：设计一个抽象的 Vehicle 类，要求所有子类必须实现 start() 方法：

class Vehicle {  
public:  
    virtual void start() = 0;  // 纯虚函数  
    virtual ~Vehicle() {}      // 虚析构函数（避免内存泄漏）  
};  

class Car : public Vehicle {  
public:  
    void start() override {  
        std::cout << "Car engine started." << std::endl;  
    }  
};

四、继承的高级应用与常见问题

4.1 多重继承与菱形问题

C++ 支持多重继承，但需谨慎使用。例如，若类 D 同时继承自 B 和 C，而 B 和 C 又继承自共同的基类 A，则 D 中会存在两个 A 的副本，引发“菱形问题”。

class A { /* ... */ };  
class B : public A { /* ... */ };  
class C : public A { /* ... */ };  
class D : public B, public C { /* ... */ };  // 可能导致菱形问题

解决方法包括：

  • 使用 virtual 关键字实现虚基类（virtual public A），确保 D 只有一个 A 副本。

4.2 继承与内存布局

派生类对象的内存布局通常包含基类子对象和派生类新增成员。例如，若 Animal 占用 16 字节，Dog 添加一个 int 类型的 barkVolume，则 Dog 对象的总大小可能为 20 字节（具体取决于编译器优化）。

4.3 继承的陷阱与最佳实践

  • 避免过度继承：继承应基于“is-a”关系（如“Dog is an Animal”），而非单纯复用代码。
  • 优先使用组合而非继承：例如，若需要复用功能但非“父子关系”，可通过成员变量组合实现。
  • 虚析构函数：若基类有指针指向派生类对象，基类必须有虚析构函数，否则派生类析构函数可能不被调用。

五、实际案例：设计一个图形系统

5.1 需求分析

假设要构建一个支持多种图形（如矩形、圆形、三角形）的系统，要求：

  1. 计算面积和周长。
  2. 支持多态调用。
  3. 可扩展新图形类型。

5.2 代码实现

#include <vector>  

class Shape {  
public:  
    virtual double area() const = 0;  
    virtual double perimeter() const = 0;  
    virtual ~Shape() {}  
};  

class Rectangle : public Shape {  
private:  
    double width, height;  
public:  
    Rectangle(double w, double h) : width(w), height(h) {}  
    double area() const override { return width * height; }  
    double perimeter() const override { return 2*(width + height); }  
};  

class Circle : public Shape {  
private:  
    double radius;  
public:  
    Circle(double r) : radius(r) {}  
    double area() const override { return 3.14 * radius * radius; }  
    double perimeter() const override { return 2 * 3.14 * radius; }  
};  

int main() {  
    std::vector<Shape*> shapes;  
    shapes.push_back(new Rectangle(3, 4));  
    shapes.push_back(new Circle(5));  

    for (auto shape : shapes) {  
        std::cout << "Area: " << shape->area() << std::endl;  
    }  

    // 释放内存  
    for (auto shape : shapes) delete shape;  
    return 0;  
}

5.3 扩展性与优势

此案例通过继承和多态，实现了：

  • 代码复用：所有图形共享 Shape 接口。
  • 灵活扩展：新增图形类型（如 Triangle）只需继承 Shape 并实现方法。
  • 统一管理：通过基类指针数组管理不同对象，简化了调用逻辑。

结论

C++ 继承不仅是语法层面的代码复用工具，更是构建可扩展、可维护系统的设计哲学。通过合理使用继承、虚函数和多态，开发者能够将复杂问题分解为层级化的模块，同时保持代码的灵活性与可扩展性。然而，继承也需谨慎设计，避免因过度使用或不当继承导致的代码耦合问题。建议读者通过实际项目不断实践，并结合设计模式（如组合优于继承）提升代码质量。

掌握继承的精髓，如同掌握了面向对象编程的“基因重组”技术，为构建更优雅、健壮的软件系统奠定坚实基础。

最新发布

查看更多文章