C++多态的实现原理详解

于 2025-04-14 00:30:00 发布
阅读量3.8k 收藏 16
点赞数 34
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16242613/article/details/147164634
版权

文章目录

1. 多态的基本概念

多态（Polymorphism）是面向对象编程的三大特性之一（封装、继承、多态），它允许不同类的对象对同一消息做出不同的响应。在C++中，多态主要分为两种：

  1. 编译时多态（静态多态）：

    • 函数重载
    • 运算符重载
    • 模板

  2. 运行时多态（动态多态）：

    • 通过虚函数和继承实现
    • 需要基类指针或引用来调用派生类的方法

本文将重点讲解运行时多态的实现原理。

2. 虚函数与多态

2.1 虚函数的基本使用

class Base {
public:
    virtual void show() {  // 虚函数
        cout << "Base show()" << endl;
    }
    virtual ~Base() {}     // 虚析构函数
};

class Derived : public Base {
public:
    void show() override {  // 重写虚函数
        cout << "Derived show()" << endl;
    }
};

int main() {
    Base* p = new Derived();
    p->show();  // 输出"Derived show()" - 多态调用
    delete p;
    return 0;
}

2.2 多态的条件

实现运行时多态需要满足以下条件：

  1. 基类中声明虚函数
  2. 派生类重写(override)该虚函数
  3. 通过基类指针或引用调用虚函数

3. 虚函数表的实现原理

3.1 虚函数表（vtable）结构

C++通过虚函数表（virtual table，简称vtable）实现多态。每个包含虚函数的类都有一个虚函数表，其中存储了该类所有虚函数的地址。

内存布局示例：

Derived 对象内存布局：
+-------------------+
| vptr              | --> 指向Derived类的虚函数表
| Base类成员变量    |
| Derived类成员变量 |
+-------------------+

Derived类的虚函数表：
+-------------------+
| &Derived::show    |
| &Base::~Base      |
+-------------------+

3.2 虚函数指针（vptr）

每个包含虚函数的类的对象中，编译器会隐式地添加一个指向虚函数表的指针（vptr）。这个指针通常位于对象内存布局的最前面。

3.3 多态调用的底层机制

当通过基类指针调用虚函数时，实际发生的是：

  1. 通过对象的vptr找到虚函数表
  2. 在虚函数表中查找函数地址
  3. 调用该地址指向的函数

伪代码表示：

(*(p->__vptr[n]))(p);  // n是虚函数在表中的索引

4. 深入理解虚函数表

4.1 单继承下的虚函数表

class Base {
public:
    virtual void func1() {}
    virtual void func2() {}
};

class Derived : public Base {
public:
    void func1() override {}
    virtual void func3() {}
};

对应的虚函数表：

Base类虚函数表：
+-------------------+
| &Base::func1      |
| &Base::func2      |
+-------------------+

Derived类虚函数表：
+-------------------+
| &Derived::func1   |  // 重写的func1
| &Base::func2      |  // 继承的func2
| &Derived::func3   |  // 新增的func3
+-------------------+

4.2 多继承下的虚函数表

class Base1 {
public:
    virtual void func1() {}
};

class Base2 {
public:
    virtual void func2() {}
};

class Derived : public Base1, public Base2 {
public:
    void func1() override {}
    void func2() override {}
    virtual void func3() {}
};

对应的虚函数表：

Derived对象内存布局：
+-------------------+
| vptr1             | --> Derived类的主虚函数表
| Base1成员         |
| vptr2             | --> Base2类的虚函数表
| Base2成员         |
| Derived成员       |
+-------------------+

主虚函数表（对应Base1）：
+-------------------+
| &Derived::func1   |
| &Derived::func3   |
+-------------------+

第二个虚函数表（对应Base2）：
+-------------------+
| &Derived::func2   |
+-------------------+

4.3 虚继承下的虚函数表

虚继承（virtual inheritance）的情况更为复杂，通常会引入虚基类表（vbtable）来处理共享基类的问题。

5. 性能考虑

5.1 虚函数调用的开销

虚函数调用比普通函数调用多出以下开销：

  1. 一次指针解引用（访问vptr）
  2. 一次虚函数表查找
  3. 可能影响内联优化

5.2 优化建议

  1. 避免不必要的虚函数
  2. 将小函数声明为非虚以便内联
  3. 对于性能关键代码，考虑使用CRTP模式实现静态多态

6. 对象切片与多态

对象切片（Object Slicing）会破坏多态：

Derived d;
Base b = d;  // 对象切片，只复制了Base部分
b.show();    // 调用Base::show()，不是多态

要避免对象切片，应始终使用指针或引用：

Derived d;
Base& b = d;  // 引用，保持多态
b.show();     // 调用Derived::show()

7. 纯虚函数与抽象类

class AbstractBase {
public:
    virtual void pureFunc() = 0;  // 纯虚函数
    virtual ~AbstractBase() {}
};

class Concrete : public AbstractBase {
public:
    void pureFunc() override {}  // 必须实现纯虚函数
};

int main() {
    // AbstractBase a;  // 错误：不能实例化抽象类
    AbstractBase* p = new Concrete();
    p->pureFunc();
    delete p;
    return 0;
}

8. RTTI与typeid

运行时类型识别（RTTI）是多态的扩展：

Base* p = new Derived();
if (typeid(*p) == typeid(Derived)) {
    cout << "p points to a Derived object" << endl;
}

// 动态类型转换
Derived* pd = dynamic_cast<Derived*>(p);
if (pd) {
    // 转换成功
}

RTTI的实现也依赖于虚函数表，通常会在虚函数表中存储类型信息。

9. 多态的实际应用示例

9.1 工厂模式

class Product {
public:
    virtual void use() = 0;
    virtual ~Product() {}
};

class ConcreteProductA : public Product {
public:
    void use() override { cout << "Using Product A" << endl; }
};

class ConcreteProductB : public Product {
public:
    void use() override { cout << "Using Product B" << endl; }
};

Product* createProduct(int type) {
    switch (type) {
        case 1: return new ConcreteProductA();
        case 2: return new ConcreteProductB();
        default: return nullptr;
    }
}

9.2 策略模式

class SortStrategy {
public:
    virtual void sort(vector<int>& data) = 0;
    virtual ~SortStrategy() {}
};

class QuickSort : public SortStrategy {
public:
    void sort(vector<int>& data) override { /* 快速排序实现 */ }
};

class MergeSort : public SortStrategy {
public:
    void sort(vector<int>& data) override { /* 归并排序实现 */ }
};

class Sorter {
    SortStrategy* strategy;
public:
    Sorter(SortStrategy* s) : strategy(s) {}
    void setStrategy(SortStrategy* s) { strategy = s; }
    void sort(vector<int>& data) { strategy->sort(data); }
};

10. 现代C++中的多态

10.1 final和override关键字

C++11引入了final和override来增强多态的安全性：

class Base {
public:
    virtual void func() {}
};

class Derived : public Base {
public:
    void func() override {}  // 明确表示重写
};

class FinalDerived : public Derived {
public:
    void func() final {}  // 禁止进一步重写
};

class Attempt : public FinalDerived {
public:
    // void func() {}  // 错误：不能重写final函数
};

10.2 使用std::variant和std::visit实现多态

C++17提供了另一种实现多态的方式：

struct Circle { void draw() const { cout << "Drawing Circle" << endl; } };
struct Square { void draw() const { cout << "Drawing Square" << endl; } };

using Shape = std::variant<Circle, Square>;

void drawShape(const Shape& shape) {
    std::visit([](const auto& s) { s.draw(); }, shape);
}

int main() {
    Shape s1 = Circle();
    Shape s2 = Square();
    drawShape(s1);  // Drawing Circle
    drawShape(s2);  // Drawing Square
    return 0;
}

11. 总结

C++多态的核心实现原理可以总结为：

  1. 虚函数表机制：每个多态类有一个虚函数表，每个对象有一个指向该表的指针
  2. 动态绑定：运行时通过虚函数表查找并调用正确的函数实现
  3. 继承关系：派生类的虚函数表基于基类的虚函数表构建
  4. RTTI支持：运行时类型信息也通常存储在虚函数表相关结构中

理解多态的底层实现有助于：

  • 编写更高效的多态代码
  • 调试复杂的继承关系问题
  • 理解C++对象模型的内存布局
  • 在需要时绕过虚函数机制进行优化

多态是C++面向对象编程中最强大的特性之一，合理使用可以大大提高代码的灵活性和可扩展性。
在这里插入图片描述

c++多态的实现
hackergin的博客
06-18 452
在面试中常常会有面试官问道，c++的多态的实现机制。那么，多态到底该如何实现呢？多态的简单介绍一般来说，多态分为两种，静态多态和动态多态。静态多态也称编译时多态，主要包括模板和重载。而动态多态则是通过类的继承和虚函数来实现，当基类和子类拥有同名同参同返回的方法，且该方法声明为虚方法，当基类对象，指针，引用指向的是派生类的对象的时候，基类对象，指针，引用在调用基类的虚函数，实际上调用的是派生类函数。这
C++多态详解
lim6ere的博客
03-29 1244
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
深入剖析C++多态的实现与原理-详解 (辛苦三万字，且看且珍惜！)
最新发布
支持一对一答疑的编程作家朱文伟的博客！
06-30 1037
在虚函数后面写上=0,这个函数就为纯虚函数.纯虚函数只能写声明,不能写函数体.
C++多态的实现原理
热门推荐
Demons的博客
05-05 3万+
一、多态的概念            多态就是多种形态，C++的多态分为静态多态与动态多态。静态多态就是重载，因为在编译期决议确定，所以称为静态多态。在编译时就可以确定函数地址。动态多态就是通过继承重写基类的虚函数实现的多态，因为实在运行时决议确定，所以称为动态多态。运行时在虚函数表中寻找调用函数的地址。     在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实...
C++ 多态的实现
02-14 166
多态 C++ 的多态，大概可分为函数重载和虚函数两类。 先说说函数重载，比较简单，就是函数参数的类型和个数不同罢了，返回值的类型不做讨论，不符合重载的定义。 函数重载是建立在name mangling上的，就是说在编译的时候，编译器会为函数生成独一无二的名字，以区别重载的函数。 我们来看例子 我们用g++ -c test.c 为其生成test.o文件，再来查看它 nm te...
文件、文件夹的操作以及多态的实现
weixin_34321977的博客
03-12 173
1. 文件的管理(File) 　　1). 读取文件 　　->文件的路径 　　->文件的格式(gb2312、utf-8) 　　　　Encoding.Default->应用到文件内容的编码(系统默认编码) 　　　　Encoding.GetEncoding("gb2312")->换成国际编码 　　2). 所有的文件操作都在Syste...
详解C++多态的实现及底层原理 - 笔记
杨
09-18 2489
C++中引入了多态的思想，说白了就是拥有多种形态，可以分为静态动态(重载，编译阶段确认函数地址)和动态动态(继承重写基类的虚函数实现的多态，在运行时从虚函数表中寻找调用函数的地址)； 1：用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2：存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 3：多态性是一个接口多种实现，是面向对象的核心，分为类的多态性和函数的多态性。 4：多态用虚函数来.
C++多态的实现及原理详细解析
01-01
1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。3. 多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。4. 多态用虚函数来实现，结合动态绑定。5. 纯虚函数是虚函数再加上= 0。6. 抽象类是指包括至少一个纯虚函数的类。 纯虚函数：virtual void breathe()=0；即抽象类！必须在子类实现这个函数!即先有名称，没内容，在派生类实现内容! 我们先看一个例子： 代码如下:#include <iostr
C++多态实现原理
weixin_61631200的博客
07-12 527
多态：当不同的对象去完成同一件事时会产生出不同的状态。
C++ 多态实现的原理
weixin_62594908的博客
05-03 451
类B没有自己的fun2()函数，因此在类B的虚函数表中保存的就是A::func2()的地址，这样，即便pa指向类B的对象，"pa->fun2();每一个有虚函数的类（或者有虚函数的派生类）都有一个虚函数表，该类的任何对象中都存放着该虚函数表的指针（也就是上文提到的vfptr指针，可以认为它是由编译器自动添加到构造函数中的指令生成的）。实际上，任何有虚函数的类以及派生类的对象都包含这多出来的4个字节，这4个字节就是实现多态的关键--它位于对象存储空间的最前端，其中存放的是虚函数表的地址。
C++ 多态的实现及原理
ljq550000的专栏
04-01 131
早期绑定：c++编译器在编译的时候，要确定每个对象调用的函数（非虚函数）的地址。 晚期绑定：在运行时再去确定对象的类型以及正确的调用函数。 虚表的创建：它初始化父类对象的虚表指针，该虚表指针指向父类的虚表，当执行子类的构造函数时，子类对象的虚表指针被初始化。 object类的定义 class object { int a; int b; public: o...
【C++】多态（多态的原理）
EWIAW_ilove的博客
05-23 1343
这篇文章讲解在C++中，多态的使用以及多态的原理，其中有讲到多继承中，多态又是怎样的
多态的实现方式
weixin_33890499的博客
10-17 432
多态的形式有： 覆盖：输入参数一样，但对于不同的派生类有不同的实现， 其多态体现在运行阶段，也就是一个父类的指针可以指向不同的派生类对象，调用不同的同名函数。 重载：类的成员函数里，允许有多个不同参数的同名函数，其多态性体现   一.多态多态（Polymorphism）按字面的意思就是“多种形状”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的...
C++中的多态机制和实现原理
guishangppy的博客
07-31 350
详解C++中的多态机制以及其原理
C++多态实现
qq_41710400的博客
08-01 120
多态公有继承 多态：同一个方法在派生类和基类中的行为是不同的，方法的行为取决于调用该方法的对象，即同一方法的行为随上下文而异。 实现多态公有继承的两种重要机制： 1.在派生类中重新定义基类方法 2.使用虚函数 virtual虚函数的作用： 如果方法是通过引用或者指针而不是对象调用，他将确定使用哪一种方法。 如果没有使用关键字virtual，程序将根据引用类型或者指针类型选择方法；如果使用了关键字v...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北辰alk

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

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

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

打赏作者

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

抵扣说明：

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

余额充值