1 类继承的概述

类继承（Class Inheritance）是面向对象编程（Object-Oriented Programming，OOP）中的一个核心概念。它允许我们创建一个新的类（子类或派生类），该类继承了另一个已存在的类（父类或基类）的属性和方法。这样，子类可以重用父类的代码，而无需重新编写。

为什么会有类的继承呢？包括以下原因：

• 代码重用： 继承允许我们创建一个新的类，这个新类继承自一个已存在的类，从而重用那个类的代码。这意味着我们不需要从头开始编写所有代码，而是可以继承已有的代码，并在此基础上进行扩展或修改。这大大提高了代码的可重用性和开发效率。
• 扩展性： 通过继承，我们可以创建更具体的子类，这些子类不仅包含父类的功能，还可以添加新的功能或覆盖父类的功能。这使得我们能够创建更灵活、更适应特定需求的类。例如，我们可以有一个表示一般形状的基类（如Shape），然后创建继承自Shape的子类来表示特定的形状（如Circle、Rectangle等）。
• 多态性： 继承是多态性的一个关键组件。多态性意味着允许不同类型的对象对同一消息做出不同的响应。通过子类覆盖父类的方法，我们可以实现多态，这样当使用父类引用指向子类对象时，将调用子类的方法而不是父类的方法。这提供了更大的灵活性和可扩展性。
• 组织代码： 继承有助于组织代码，使其更加清晰和易于理解。通过将相似的功能或行为封装在基类中，并在需要时进行扩展或特化，我们可以创建一个结构良好、易于维护的代码库。
• 构建复杂的层次结构： 在现实世界中，很多事物都有层次结构关系。例如，动物是一个基类，而狗、猫等是动物类的子类。通过使用继承，我们可以模拟这种层次结构，并在代码中反映出来。这有助于创建更复杂、更逼真的模型。
• 促进软件设计原则： 继承是面向对象设计原则（如单一职责原则、开放封闭原则、里氏替换原则等）的重要实现手段。通过合理地使用继承，我们可以遵循这些原则，从而创建出更加健壮、可扩展和可维护的软件系统。

2 基类和派生类定义

2.1 基类定义

基类（Base Class）是一个被其他类继承的类。在C++中，基类的定义与其他类的定义非常相似，但它被设计为被其他类继承。基类通常包含一些公共的（public）和保护的（protected）成员变量和成员函数，这些成员可以被派生类访问和使用。基类提供了一种代码重用和扩展的机制，允许派生类继承基类的属性和行为，并添加或覆盖自己的特定实现。

基类的定义语法格式如下：

class BaseClass 
{
public:
    // 公共构造函数
    BaseClass() 
    {
        // 初始化代码
    }

    // 公共析构函数（通常声明为虚函数）
    virtual ~BaseClass() 
    {
        // 清理代码
    }

    // 公共成员函数
    void publicFunction() 
    {
        // 公共成员函数的实现
    }

protected:
    // 受保护的成员变量
    int protectedVariable;

    // 受保护的成员函数
    void protectedFunction() 
    {
        // 受保护成员函数的实现
    }

private:
    // 私有成员变量
    int privateVariable;

    // 私有成员函数
    void privateFunction() 
    {
        // 私有成员函数的实现
    }
};

其中，

• virtual 关键字用于声明析构函数为虚函数。这允许在删除指向派生类对象的基类指针时，调用正确的析构函数（派生类的析构函数），从而正确释放资源。
• public 部分声明了公共构造函数 BaseClass() 和公共成员函数 publicFunction()。这些成员可以被任何对象（包括派生类对象）访问。
• protected 部分声明了一个受保护的成员变量 protectedVariable 和一个受保护的成员函数 protectedFunction()。这些成员可以被派生类访问，但不能被派生类对象或基类对象之外的其他代码访问。
• private 部分声明了一个私有成员变量 privateVariable 和一个私有成员函数 privateFunction()。这些成员只能被基类自身访问，不能被派生类或其他代码访问。

2.2 派生类定义

派生类（Derived Class）继承自一个或多个已有的类（称为基类或父类）。派生类继承了基类的所有公有（public）和保护（protected）成员（包括属性和方法），并可以添加新的成员或重写（override）基类的成员。

派生类的主要目的是实现代码的重用和扩展性。通过继承基类，派生类可以自动拥有基类中的所有非私有成员，这意味着派生类不需要重新实现这些成员，从而减少了代码量。同时，派生类还可以添加自己的新成员，以满足特定的需求。

派生类定义的语法格式如下：

// 基类定义
class BaseClass 
{
public:
    // 基类的构造函数
    BaseClass();
    
    // 基类的析构函数
    virtual ~BaseClass();    
    
    // 基类的公有成员
    void publicFunction();
    
protected:
    // 基类的受保护成员
    int protectedVariable;
    
private:
    // 基类的私有成员
    int privateVariable;
};

// 派生类定义
class DerivedClass : access_modifier BaseClass 
{
public:
    // 派生类的构造函数
    DerivedClass();
    
    // 派生类的析构函数
    virtual ~DerivedClass();
    
    // 派生类的公有成员
    void anotherPublicFunction();
    
protected:
    // 派生类的受保护成员
    int anotherProtectedVariable;
    
private:
    // 派生类的私有成员
    int anotherPrivateVariable;
    
    // 如果需要，可以在这里初始化基类成员
    using BaseClass::baseMemberFunction; // 访问基类中的成员
    
    // 重写基类中的虚函数
    void virtualFunction() override;
};

// 派生类的构造函数实现
DerivedClass::DerivedClass() : BaseClass() 
{
    // 派生类构造函数的初始化列表，可以调用基类的构造函数
    // 初始化派生类特有的成员
}

// 派生类的析构函数实现
DerivedClass::~DerivedClass()
{
    // 清理派生类特有的资源
}

// 派生类成员函数的实现
void DerivedClass::anotherPublicFunction() 
{
    // 实现派生类的另一个公有成员函数
}

// 重写基类虚函数的实现
void DerivedClass::virtualFunction() 
{
    // 实现重写的虚函数
}

其中， access_modifier指定继承方式，包括public、protected 或 private三种方式。

2.3 综合案例

我们先定义一个形状的Shape基类，它包含一些通用的属性和方法。然后，将从这个基类派生出Circle和Rectangle类，它们分别表示圆形和矩形，并添加各自特有的属性和方法。

#include <iostream>
#include <string>

// 基类Shape定义
class Shape 
{
public:
    // 构造函数
    Shape(const std::string& color) : color(color)
    {
    }
    
    // 析构函数
    virtual ~Shape()
    {
    }
    
    // 公有成员函数
    virtual void Draw() const 
    {
        std::cout << "Drawing a shape of color " << color << std::endl;
    }
    
    virtual double GetArea() const 
    {
        return 0.0; // 基类中的默认实现，可能会被派生类重写
    }
    
protected:
    // 受保护成员变量
    std::string color;
};

// 派生类圆形类Circle定义
class Circle : public Shape 
{
public:
    // 构造函数
    Circle(double r, const std::string& color) :Shape(color), radius(r)
    {
    }
    
    // 析构函数
    virtual ~Circle()
    {
    }

    // 重写基类的draw函数
    void Draw() const override 
    {
        std::cout << "Drawing a circle with radius " << radius 
            		<< " and color " << color << std::endl;
    }

    // 重写基类的getArea函数
    double GetArea() const override
    {
        return 3.14 * radius * radius; // 近似计算圆的面积
    }
    
private:
    // 私有成员变量
    double radius;    
};

// 派生类矩形类Rectangle定义
class Rectangle : public Shape 
{
public:
    // 构造函数
    Rectangle(double w, double h, const std::string& color) 
        : Shape(color), width(w), height(h) 
    {
    }

    // 重写基类的draw函数
    void Draw() const override 
    {
        std::cout << "Drawing a rectangle with width " << width 
            		<< " and height " << height 
            		<< " and color " << color << std::endl;
    }

    // 重写基类的getArea函数
    double GetArea() const override 
    {
        return width * height;
    }
    
private:
    // 私有成员变量
    double width;
    double height;    
};


int main() 
{
    // 创建圆形和矩形的对象
    Circle circle(5, "red");
    Rectangle rectangle(4, 6, "blue");

    // 调用对象的成员函数
    circle.Draw();
    std::cout << "Circle area: " << circle.GetArea() << std::endl;

    rectangle.Draw();
    std::cout << "Rectangle area: " << rectangle.GetArea() << std::endl;

    return 0;
}

其中，

• Shape类提供了Draw和GetArea方法的默认实现。
• 派生类Circle和Rectangle通过重写（override关键字）这些方法提供特定的实现。
• 如果基类Shape中的Draw和GetArea不是虚函数（virtual关键字定义），那么，派生类Circle和Rectangle中使用了override关键字重写这些函数时，编译器会报错。

扩展知识：

在C++11及后续版本中，override关键字用于显式指示一个成员函数打算重写（override）基类中的虚函数。使用override关键字可以帮助编译器检查你的意图是否正确：如果基类中没有你要重写的虚函数，编译器将产生一个错误。

override关键字增加了代码的可读性和安全性，因为它明确表明了你正在重写基类中的某个函数，而不是创建一个新的、可能名称相似的函数。如果基类中的虚函数在未来的某个版本中被删除或更改了签名，使用override关键字的代码将不会编译通过，从而提醒开发者需要更新代码。

---E N D---

喜欢的记得关注哦！

您的支持是我们前进的动力！

职创未来|专注IT与新能源领域中高端人才培养