c++八股 封装继承 多态

八股是指编程中常见的一些基本概念和思想，封装、继承和多态是其中的三个重要概念。

封装（Encapsulation）是指将数据和对数据的操作封装在一起，形成一个类或对象。通过封装，可以隐藏数据的具体实现细节，只提供对外的接口访问方式。这样可以提高代码的可维护性和可复用性。

继承（Inheritance）是指一个类可以继承另一个类的属性和方法。通过继承，子类可以直接使用父类的属性和方法，同时还可以在子类中添加新的属性和方法，或者重写父类的方法。继承可以提高代码的复用性和扩展性。

多态（Polymorphism）是指一个对象可以具有多种形态，即同一种类型的对象在不同情况下表现出不同的行为。通过多态，可以通过统一的接口来处理不同类型的对象，提高代码的灵活性和可扩展性。

这些概念在面向对象编程中非常重要，可以帮助我们设计出结构清晰、可扩展、可维护的代码。如果你对这些概念还有其他疑问，我可以继续为你解答。

相关问题

c++封装继承多态练习

### 关于C++中封装、继承和多态的练习示例

#### 定义基类 `Animal`

为了展示封装、继承和多态的概念，下面定义了一个名为`Animal`的抽象基类。该类包含了两个成员变量用于存储动物的名字和年龄，并提供了一些公共接口来访问这些私有数据。

#include <iostream>
#include <string>

class Animal {
protected:
    std::string name;
    int age;

public:
    // 构造函数初始化列表设置name和age
    Animal(const std::string& n, int a): name(n), age(a) {}

    // 虚析构函数确保派生类的对象能够被正确销毁
    virtual ~Animal() = default;

    // 获取名字的方法
    const std::string& getName() const { return name; }

    // 获取年龄的方法
    int getAge() const { return age; }

    // 声明纯虚函数makeSound(), 表示这是一个抽象类
    virtual void makeSound() const = 0;
};

#### 创建派生类 `Dog` 和 `Cat`

接下来分别创建了两个具体的子类——`Dog`和`Cat`，这两个类都从`Animal`继承而来并实现了各自的`makeSound()`方法以体现不同的行为特征。

// Dog 类继承自 Animal 并覆写了 makeSound 方法
class Dog : public Animal {
public:
    using Animal::Animal; // 使用基类构造器
    
    void makeSound() const override {
        std::cout << "Woof! Woof!" << std::endl;
    }
};

// Cat 类同样继承自 Animal 并提供了自己的 makeSound 版本
class Cat : public Animal {
public:
    using Animal::Animal; // 同样使用基类构造器
    
    void makeSound() const override {
        std::cout << "Meow... Meow..." << std::endl;
    }
};

#### 测试代码片段

最后编写一段简单的测试程序，在其中利用指向基类型的指针数组保存不同类型的具体对象实例，并调用其共有的接口来进行操作，以此验证多态机制的效果。

int main() {
    // 动态分配内存空间给不同种类的动物对象
    Animal* animals[] = {
        new Dog("Buddy", 5),
        new Cat("Whiskers", 3)
    };

    // 遍历数组并通过基类指针调用各自版本的 makeSound 函数
    for (auto animal : animals) {
        std::cout << "This is " << animal->getName()
                  << ", who says ";
        animal->makeSound();
    }

    // 清理资源释放动态分配的空间
    for (auto animal : animals) delete animal;

    return 0;
}

这段代码展示了如何运用C++中的三大支柱特性：通过保护成员变量实现**封装**；借助公有继承关系建立层次结构从而支持**继承**；而基于虚函数表机制则让运行时可以识别出正确的成员函数执行路径进而达成**多态**效果[^1]。

c++封装继承多态的理解

### C++ 中的封装、继承和多态

#### 封装
封装是指将数据成员（属性）和成员函数（方法）绑定在一起形成一个独立的整体——即类。通过访问控制符 `private` 或者 `protected` 来隐藏对象的具体实现细节，只暴露必要的公共接口给外部使用。这种方式不仅保护了数据的安全性，也提高了模块间的解耦合度。

class Person {
private:
    std::string name;
public:
    void setName(const std::string& newName);
    const std::string& getName() const;
};

上述代码展示了如何利用私有成员变量存储姓名信息，并提供公有的设置器(setter) 和获取器(getter)，以此达到对外部世界屏蔽内部表示的目的[^1]。

#### 继承
继承允许创建新的类基于已存在的类，子类会自动获得父类所有的非私有成员以及定义的方法。这有助于减少重复代码量并促进软件组件之间的共享与复用。C++ 支持单继承或多层继承结构；而 Java 则仅限于单一继承模式以简化设计复杂度[^2]。

// 基础类 Shape 定义了一些通用属性和行为
class Shape {
public:
    virtual double area() = 0; // 纯虚函数声明
};

// Circle 类从 Shape 派生而来，实现了特定形状下的面积计算逻辑
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r):radius(r){}
    double area(){return M_PI * pow(radius, 2);}
};

这里展示了一个简单的几何图形抽象基类 `Shape` 及其派生具体类型的例子 `Circle` ，体现了继承机制的应用场景之一。

#### 多态
多态意味着同一个操作作用于不同的对象上会产生不同形式的结果。它通常借助于虚函数表(virtual table) 实现运行时动态分发调用。当基类指针指向派生类实例时，在执行某些成员函数时能够根据实际所指的对象类型来决定最终要调用哪个版本的方法体。这种灵活性极大地增强了系统的可维护性和适应变化的能力[^3]。

#include <iostream>
using namespace std;

class Animal{
public:
    virtual void speak()=0; // 抽象类中的纯虚函数
};

class Dog:public Animal{
public:
    void speak(){
        cout << "Woof!"<<endl;
    }
};

int main(){
    Animal* pAnimal=new Dog();
    pAnimal->speak(); // 输出 Woof! 表明发生了向下的类型转换后的正确响应
}

此片段说明了即使是在编译期间无法得知确切的目标实体的情况下也能保证正确的语义表达，这就是所谓的“后期绑定”或称为“动态联编”。