第八章聚焦于C++的多态（Polymorphism），这是面向对象编程（OOP）的三大特性之一（封装、继承、多态）

最新推荐文章于 2025-10-03 13:07:23 发布
原创 最新推荐文章于 2025-10-03 13:07:23 发布 · 845 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

本章聚焦于C++的多态（Polymorphism），这是面向对象编程（OOP）的三大特性之一（封装、继承、多态），与之前的章节（第一章：C++基础、第二章：类和对象（上）、第三章：类和对象（下）、第四章：内存管理、第五章：模板、第六章：STL、第七章：继承、第十五章：哈希表）紧密相关。多态为实现灵活、可扩展的代码提供了支持，尤其在设计复杂数据结构（如哈希表）时非常有用。简要概述每个部分的内容，提供简洁的C++代码示例，并保持与之前学习的章节衔接。

前言

多态允许同一接口在不同对象上表现出不同行为，是C++面向对象编程的核心特性。本章介绍多态的实现、虚函数、抽象类、虚函数表等内容，为实现动态行为和设计模式奠定基础，同时与哈希表等数据结构的扩展性设计相关。

1. 多态的概念

  • 多态：同一操作作用于不同对象，产生不同行为。
  • 分类：
    • 编译期多态：通过函数重载、模板（第五章）实现。
    • 运行期多态：通过继承和虚函数实现，动态绑定行为。
  • 应用：多态提高代码扩展性和复用性，常见于框架设计和接口实现。

2. 多态的实现

运行期多态通过继承（第七章）和虚函数实现：

  • 基类定义虚函数，派生类重写（override）以提供特定实现。
  • 通过基类指针或引用调用虚函数，动态绑定到实际对象类型。

代码示例：

#include <iostream>

class Base {
public:
    virtual void print() { std::cout << "Base" << std::endl; } // 虚函数
};

class Derived : public Base {
public:
    void print() override { std::cout << "Derived" << std::endl; } // 重写
};

int main() {
    Base* b = new Derived(); // 基类指针指向派生类
    b->print(); // 输出：Derived（动态绑定）
    delete b;
    return 0;
}

3. 虚函数的重写

3.1 重写
  • 派生类重写基类的虚函数，函数签名（名称、参数、返回值）必须一致。
  • 需在基类中用virtual关键字标记虚函数。

代码示例：

#include <iostream>

class Base {
public:
    virtual void func() { std::cout << "Base func" << std::endl; }
};

class Derived : public Base {
public:
    void func() override { std::cout << "Derived func" << std::endl; }
};

int main() {
    Base* b = new Derived();
    b->func(); // 输出：Derived func
    delete b;
    return 0;
}
3.2 协变

协变允许派生类重写虚函数时，返回类型是基类返回类型的派生类（通常用于指针或引用）。

代码示例：

#include <iostream>

class Base {
public:
    virtual Base* clone() { return new Base(); }
};

class Derived : public Base {
public:
    Derived* clone() override { return new Derived(); } // 协变返回类型
};

int main() {
    Base* b = new Derived();
    Base* c = b->clone(); // 返回Derived*，但安全转换为Base*
    delete b;
    delete c;
    return 0;
}
3.3 析构函数的重写
  • 基类析构函数应声明为virtual，否则通过基类指针删除派生类对象时，只调用基类析构函数，可能导致资源泄漏。
  • 派生类析构函数自动重写基类的虚析构函数。

代码示例：

#include <iostream>

class Base {
public:
    virtual ~Base() { std::cout << "Base destructor" << std::endl; }
};

class Derived : public Base {
public:
    ~Derived() override { std::cout << "Derived destructor" << std::endl; }
};

int main() {
    Base* b = new Derived();
    delete b; // 输出：Derived destructor, Base destructor
    return 0;
}
3.4 override和final关键字
  • override（C++11）：显式声明函数重写基类虚函数，确保签名匹配。
  • final（C++11）：禁止派生类进一步重写虚函数或继承类。

代码示例：

#include <iostream>

class Base {
public:
    virtual void func() { std::cout << "Base func" << std::endl; }
};

class Derived : public Base {
public:
    void func() override final { std::cout << "Derived func" << std::endl; } // final禁止重写
};

class SubDerived : public Derived {
    // void func() override; // 错误：func是final
};

int main() {
    Base* b = new Derived();
    b->func(); // 输出：Derived func
    delete b;
    return 0;
}
3.5 重载、重写和隐藏的对比（重点）
特性重载（Overload）重写（Override）隐藏（Hiding）
定义同作用域，函数名相同，参数不同继承关系，虚函数签名一致派生类同名函数隐藏基类函数
关键字无virtual/override无
作用域同一类或命名空间基类与派生类基类与派生类
绑定编译期运行期（动态绑定）编译期

代码示例：

#include <iostream>

class Base {
public:
    virtual void func() { std::cout << "Base func" << std::endl; } // 虚函数
    void func(int x) { std::cout << "Base func with int: " << x << std::endl; } // 重载
};

class Derived : public Base {
public:
    void func() override { std::cout << "Derived func" << std::endl; } // 重写
    void func(double x) { std::cout << "Derived func with double: " << x << std::endl; } // 隐藏
};

int main() {
    Base* b = new Derived();
    b->func(); // 输出：Derived func（重写）
    // b->func(3.14); // 错误：Base无func(double)
    Derived d;
    d.func(3.14); // 输出：Derived func with double: 3.14（隐藏）
    d.Base::func(5); // 输出：Base func with int: 5（访问隐藏的基类函数）
    delete b;
    return 0;
}

5. 纯虚函数和抽象类

  • 纯虚函数：声明为virtual void func() = 0;，无实现，派生类必须重写。
  • 抽象类：包含至少一个纯虚函数的类，不能实例化，常用作接口。

代码示例：

#include <iostream>

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
    virtual ~Shape() = default; // 虚析构函数
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "Draw Circle" << std::endl; }
};

int main() {
    // Shape s; // 错误：抽象类不可实例化
    Shape* s = new Circle();
    s->draw(); // 输出：Draw Circle
    delete s;
    return 0;
}

6. 多态的原理

  • 运行期多态通过**虚函数表（vtable）**实现。
  • 基类指针或引用调用虚函数时，根据对象实际类型的vtable查找函数地址。
  • 虚函数调用有少量运行时开销，但提供动态行为。

7. 虚函数表

  • 虚函数表（vtable）：每个包含虚函数的类有一个vtable，存储虚函数地址。
  • 对象布局：对象包含一个虚表指针（vptr），指向类的vtable。
  • 动态绑定：通过vptr查找vtable中的函数地址。

代码示例（示意vtable行为）：

#include <iostream>

class Base {
public:
    virtual void func1() { std::cout << "Base func1" << std::endl; }
    virtual void func2() { std::cout << "Base func2" << std::endl; }
};

class Derived : public Base {
public:
    void func1() override { std::cout << "Derived func1" << std::endl; }
};

int main() {
    Base* b = new Derived();
    b->func1(); // 输出：Derived func1（通过vtable调用）
    b->func2(); // 输出：Base func2
    delete b;
    return 0;
}

8. 动态绑定与静态绑定

  • 动态绑定：运行期通过vtable确定虚函数调用，适用于多态。
  • 静态绑定：编译期确定函数调用，适用于非虚函数或直接调用。
  • 区别：
    • 动态绑定：基类指针/引用调用虚函数，运行时解析。
    • 静态绑定：函数调用在编译时确定，效率更高。

代码示例：

#include <iostream>

class Base {
public:
    virtual void dynamicFunc() { std::cout << "Base dynamic" << std::endl; }
    void staticFunc() { std::cout << "Base static" << std::endl; }
};

class Derived : public Base {
public:
    void dynamicFunc() override { std::cout << "Derived dynamic" << std::endl; }
    void staticFunc() { std::cout << "Derived static" << std::endl; }
};

int main() {
    Base* b = new Derived();
    b->dynamicFunc(); // 输出：Derived dynamic（动态绑定）
    b->staticFunc();  // 输出：Base static（静态绑定）
    delete b;
    return 0;
}

尾声

多态通过虚函数和动态绑定实现了灵活的行为切换，是C++面向对象编程的核心。本章内容为实现复杂数据结构（如哈希表）提供了扩展性支持，同时为后续学习设计模式和高级OOP技术奠定了基础。

补充说明

  • 与哈希表章节的衔接：多态可用于哈希表的扩展设计。例如，定义一个抽象基类HashTableBase（含纯虚函数），派生出不同的哈希表实现（如链地址法、开放寻址法）。
    示例多态哈希表（结合第八章和第十五章）：
    #include <iostream>
#include <list>

template<typename K, typename V>
class HashTableBase {
public:
    virtual void insert(K key, V value) = 0;
    virtual V find(K key) const = 0;
    virtual ~HashTableBase() = default;
};

template<typename K, typename V>
class ChainingHashTable : public HashTableBase<K, V> {
private:
    static const int SIZE = 10;
    std::list<std::pair<K, V>> table[SIZE];
public:
    void insert(K key, V value) override {
        table[std::hash<K>{}(key) % SIZE].push_back({key, value});
    }
    V find(K key) const override {
        for (const auto& pair : table[std::hash<K>{}(key) % SIZE]) {
            if (pair.first == key) return pair.second;
        }
        return V();
    }
};

int main() {
    HashTableBase<int, std::string>* ht = new ChainingHashTable<int, std::string>();
    ht->insert(1, "Alice");
    std::cout << ht->find(1) << std::endl; // 输出：Alice
    delete ht;
    return 0;
}
  • 进一步需求：
    • 如果你需要更详细的代码实现（如虚函数表的可视化、不同哈希表实现的比较）、图表（例如vtable结构图）、或某一节的深入讲解（如动态绑定的底层机制），请告诉我。
    • 如果你有其他章节的内容需要讲解，或想结合第一章至第七章、第十五章的内容，请具体说明！

希望这部分解答对你学习C++多态有帮助！😊 如果有任何问题，随时告诉我！

【C++ | 面向对象思想】 C++ 的面向对象(OOP)思想详解：抽象、封装、继承、多态
wkd_007的博客
05-30 1715
👉本文介绍了面向过程和面向对象的区别，然后介绍了几个面向对象的特性：抽象、封装、继承、多态。
面向对象编程（OOP）-继承、封装、多态
小王爱吃月亮糖的博客
12-20 1152
C++中的继承、封装和多态。这三个概念是面向对象编程（OOP）的核心。
《C++中的面向对象编程三大特性：封装、继承与多态》
xy520521的博客
09-05 1494
由于 draw 函数是虚函数，所以实际调用的是 Circle 和 Rectangle 类中的 draw 函数，而不是 Shape 类中的函数。在 C++编程的广阔世界中，面向对象编程（Object-Oriented Programming，OOP）的三大特性——封装、继承和多态，犹如三把强大的利器，帮助程序员构建出高效、可维护和可扩展的软件系统。2. 代码可维护性：封装使得类的内部实现细节与外部代码分离，当我们需要修改类的内部实现时，只需要修改类的内部代码，而不会影响外部代码。
【C++面向对象编程】四大基本特性之三：多态
byte轻骑兵的技术小窝
09-05 1260
多态是C++面向对象编程中的重要特性之一，它允许使用共同的接口来处理不同类型的对象，从而提高了代码的灵活性和可扩展性。通过继承和虚函数，C++实现了动态多态；通过函数重载和运算符重载，C++实现了静态多态。多态与继承、封装相结合，可以构建出更加模块化、易于维护和扩展的程序。
面向对象编程三大特性（封装、继承、多态）
weixin_42868530的博客
09-19 623
面向对象编程（Object-Oriented Programming，简称OOP）三大核心特性：封装、继承和多态。这些特性是面向对象编程的基石，为我们构建可维护、可扩展和可复用的软件提供了坚实的基础。
【入门向】C++ 的三大特性：封装、继承与多态
Ahu_iii的博客
05-14 1279
C++中的面向对象编程（OOP）依赖于三大核心特性：封装、继承和多态。封装通过隐藏内部实现细节，仅暴露公共接口，提高了代码的安全性和模块化。C++通过访问修饰符（private、protected、public）实现封装，确保数据保护和接口稳定性。继承允许子类复用父类的属性和方法，建立类之间的层次结构，支持单继承和多继承。多继承可能导致菱形继承问题，C++通过虚继承解决。继承设计应遵循“is-a”关系，避免滥用多继承。这些特性共同提升了代码的可读性、可维护性和扩展性。
C++ 之多态 ------ C++面向对象三大特性之一【三大特性：封装、继承、多态】
xinxin的博客
03-20 912
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类代码组织结构清晰可读性强利于前期和后期的扩展以及维护。
面试题解析 | 面向对象三大特征：封装、继承、多态（附C++代码实现）
C语言实战大全
07-12 816
​封装是将数据和操作数据的方法绑定为类，并对外隐藏内部实现细节的过程。通过privateprotectedpublic等访问控制符，实现对数据的保护与接口的暴露​核心作用​数据保护​：防止外部直接修改敏感数据（如银行账户余额）​接口隔离​：通过公有方法（如）提供安全访问途径。​降低耦合​：修改内部实现不影响外部调用（例如更换日志记录方式）​继承允许子类复用父类的属性和方法，形成类层次结构。继承方式父类成员访问权限变化适用场景public父类public→子类public通用继承（如Dog。
一篇文章搞定面向对象三大特性：封装、继承、多态
2301_78977377的博客
08-25 1199
封装是面向对象编程的第一大特性。它指的是将数据（属性）和操作数据的方法（行为）捆绑在一起，形成一个独立的单元——类（Class）。同时，它还通过访问修饰符（publicprivateprotected）来限制外部对类内部成员的直接访问，只暴露必要的接口。你知道它能做什么（通过公共接口），但你不需要知道它是怎么做的（内部实现细节被隐藏）。比如电视遥控器，你按“音量+”，电视音量就变大，你不需要知道遥控器内部的电路是怎么工作的。
C++基础入门：面相对象编程C++中的封装、继承和多态.docx
08-06
面向对象编程（OOP）是软件开发中的一种核心方法，C++ 作为支持OOP的强类型编程语言，封装、继承和多态是其三大重要特性。这些特性使得C++能够更好地模拟现实世界中的问题，提高代码的复用性和可维护性。 1. 封装...
探索C++语言特性和应用场景: 面向对象与高效编程的典范
01-31
更重要的是对OOP三大支柱——封装（class & object）、继承(inheritance)、多态(polymorphism)的具体介绍，并提供了丰富的代码示例。在讨论应用领域部分，则重点提到C++适用于系统软件(如操作系统、编译器)、游戏...
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
C++是支持OOP的重要编程语言，提供了类（Class）、对象（Object）、继承（Inheritance）、多态（Polymorphism）等特性。 1. **类与对象**：在C++中，类定义了一种数据结构，它是对象的蓝图。对象是类的实例，包含了...
C++中的封装、继承、多态理解
08-25
C++编程语言中的封装、继承、多态是面向对象编程（OOP）的三个基本概念。它们是C++编程语言中的核心机制，用于实现代码重用、模块化和接口重用。 封装 封装（Encapsulation）是将抽象得到的数据和行为（或功能）相...
【C++】list的使用与模拟实现
最新发布
suxi_na的博客
10-03 473
本文介绍了C++ STL中list容器的使用与模拟实现。list作为双向链表容器，与vector的动态数组结构不同，具有独特的插入删除优势。文章首先通过文档介绍list的基本用法，包括构造、迭代器分类等，重点讲解了list迭代器失效问题。随后详细展示了list的模拟实现过程，包括节点封装、迭代器封装（通过模板参数实现iterator和const_iterator的复用）以及list主框架设计。通过对比vector，突出了list作为链表结构的特点，并提供了完整的代码示例，帮助读者深入理解list的底层实现原
2025.8.10-学习C++（一）
weixin_51652691的博客
09-29 1390
如果没有定义，就编译接下来的代码。
C语言中的浮点数与整数的存储方式
jackispy的博客
09-27 1178
特性整数（int, long等）浮点数（float, double）表示内容整数值（正、负或零）带小数部分的实数（可能有精度损失）存储格式二进制原码或补码IEEE 754 标准（符号、指数、尾数）是否有精度问题无有（特别是小数，如 0.1 无法精确表示）比较操作直接比较是否相等不可直接比较是否相等，应考虑误差范围典型用途计数、索引、离散值科学计算、测量值、图形坐标等连续值常见类型（32位系统）int（32位）、long（32/64位）
【C++】对象和类
qq_34142812的博客
10-01 642
C++ 11 类的定义和使用简介.
高通平台WiFi学习--深入解析 WCN39xx/PMIC GPIO/LDO 状态读取与调试
weixin_47456647的博客
09-28 160
在嵌入式系统尤其是涉及无线局域网（WLAN）模块的设备中，电源管理集成电路（PMIC）以及通用输入输出（GPIO）、低压差线性稳压器（LDO）的状态对于模块能否正常工作至关重要。本文将详细介绍如何读取 WCN39xx/PMIC 的 GPIO 和 LDO 状态，以及相关的调试方法。
现代C++ Lambda表达式：最佳实践、深入理解和资源推荐
软件开发领域最优质的博客
09-28 1605
本文深入探讨了现代C++中Lambda表达式的最佳实践和核心概念。主要内容包括：避免默认捕获模式以防止空悬引用，使用C++14初始化捕获移动对象优化性能，正确处理auto&&形参的完美转发，以及优先选择Lambda而非std::bind的优势。文章还提供了Lambda捕获机制解析和推荐学习资源（如《Effective Modern C++》和cppreference），并建议通过项目实战巩固理解。这些内容帮助开发者更安全高效地使用Lambda，提升代码质量和性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

张工在路上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值