基础知识|C++|封装、继承、多态

一、封装、继承、多态是什么

封装：将具体实现过程和数据封装成一个函数，只能通过接口进行访问，降低耦合性，使类成为一个具有内部数据的自我隐藏能力、功能独立的软件模块。

意义：保护或防止代码在无意之中被破坏，保护类中的成员，不让类中以外的程序直接访问或者修改，只能通过提供的公共接口访问。

继承：子类继承父类的特征和行为，复用了基类的全体数据和成员函数，具有从基类复制而来的数据成员和成员函数（基类私有成员可被继承，但是无法被访问），其中构造函数、析构函数、友元函数、静态数据成员、静态成员函数都不能被继承。基类中成员的访问方式只能决定派生类能否访问它们。增强了代码耦合性，当父类中的成员变量或者类本身被final关键字修饰时，修饰的类不能被继承，修饰的成员变量不能重写或修改。

意义：基类的程序代码可以被派生类服用，提高了软件复用的效率，缩短了软件开发的周期

多态：不同继承类的对象对同一消息做出不同的响应，基类的指针指向或绑定到派生类的对象，使得基类指针呈现不同的表现形式。

意义：对已存在的代码具有可替代性，对代码具有可扩充性，新增子类不会影响已存在类的各种性质，在程序中体现了灵活多样的操作，提高了使用效率，简化了对应用代码的编写和修改过程。

二、继承的方式

（一）私有，保护，公有权限

        public： 类外部可以访问

        protected：类内部和子类可以访问

        private：只有类内部可以访问

（二）私有，保护，公有继承

public： 子类权限保持不变

protected：子类继承的：private，protected不变 ，public降为protected

private：子类继承的 ：public、protected 降为private

三、多态的实现方式

        多态分为动态多态（动态多态是利用虚函数实现运行时的多态，即在系统编译的时候并不知道程序将要调用哪一个函数，只有在运行到这里的时候才能确定接下来会跳转到哪一个函数。）和静态多态（又称编译期多态，即在系统编译期间就可以确定程序将要执行哪个函数）

（一）动态多态

        虚函数是类的成员函数，存在存储虚函数指针的表叫做虚函数表，虚函数表是一个存储类成员虚函数的指针，每个指针都指向调用它的地方，当子类调用虚函数时，就会去虚表里面找自己对应的函数指针，从而实现“谁调用、实现谁”从而实现多态。

#include <iostream>

// 声明抽象基类 Shape
class Shape {
public:
    virtual ~Shape() {} // 虚析构函数确保派生类的析构函数也是虚的
    virtual void draw() const = 0; // 纯虚函数
};

// Circle 类继承自 Shape
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// Square 类继承自 Shape
class Square : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a square." << std::endl;
    }
};

// 函数声明
void draw_shape(const Shape& shape);

int main() {
    // 创建 Circle 和 Square 对象
    Circle circle;
    Square square;

    // 使用 draw_shape 函数，传递不同类型的 Shape 对象
    draw_shape(circle);
    draw_shape(square);

    return 0;
}

// 函数定义
void draw_shape(const Shape& shape) {
    shape.draw(); // 动态绑定，根据传入的对象类型调用相应的 draw 方法
}

输出：

Drawing a circle.

Drawing a square. 

（二）静态多态

        静态多态则是通过函数重载（函数名相同，参数不同，两个函数在同一作用域），运算符重载，和重定义（又叫隐藏，指的是在继承关系中，子类实现了一个和父类名字一样的函数，（只关注函数名，和参数与返回值无关）这样的话子类的函数就把父类的同名函数隐藏了。隐藏只与函数名有关，与参数没有关系.）来实现的。

#include <iostream>

// Calculator 类
class Calculator {
public:
    // 重载 add 函数，接受两个 int 参数
    int add(int a, int b) {
        return a + b;
    }

    // 重载 add 函数，接受两个 double 参数
    double add(double a, double b) {
        return a + b;
    }

    // 重载 add 函数，接受三个 int 参数
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

// 函数声明
void useCalculator();

int main() {
    useCalculator();
    return 0;
}

// 函数定义
void useCalculator() {
    Calculator calc;

    // 使用重载的 add 函数
    int sum1 = calc.add(1, 2); // 调用第一个重载的 add 函数
    double sum2 = calc.add(1.5, 2.5); // 调用第二个重载的 add 函数
    int sum3 = calc.add(1, 2, 3); // 调用第三个重载的 add 函数

    std::cout << "Sum of 1 and 2: " << sum1 << std::endl;
    std::cout << "Sum of 1.5 and 2.5: " << sum2 << std::endl;
    std::cout << "Sum of 1, 2, and 3: " << sum3 << std::endl;
}

Sum of 1 and 2: 3

Sum of 1.5 and 2.5: 4

Sum of 1, 2, and 3: 6