关注我，学习c++不迷路:

个人主页：爱装代码的小瓶子
专栏如下：

1. c++学习
2. Linux学习

后续会更新更多有趣的小知识，关注我带你遨游知识世界

期待你的关注。

深入探索C++虚函数：从编译器视角看多态的“幕后魔法”

前言：在上一篇文章中，我们聊了C++多态的基本概念，知道了“同一接口，多种实现”的妙处。但你是否好奇过，编译器在底层到底做了什么手脚？为什么加了一个virtual关键字，程序就能在运行时“聪明”地找到正确的函数？
今天，小瓶子带大家钻进编译器的“肚子里”，不再只谈语法，而是从内存布局、虚表指针（vptr）和虚函数表（vtable）的角度，彻底搞懂虚函数的原理。这部分内容也是大厂面试中考察C++深度的重灾区哦！

1. 一个奇怪的现象：类的大小变了？

在深入原理之前，我们先看一段看似简单的代码。请大家猜猜，下面两个类的大小（sizeof）分别是多少？（假设在64位系统下）

#include<iostream>usingnamespacestd;// 这是一个普通的空类classA{public:voidfunc(){cout<<"A::func"<<endl;}};// 这是一个带虚函数的空类classB{public:virtualvoidfunc(){cout<<"B::func"<<endl;}};intmain(){cout<<"sizeof(A) = "<<sizeof(A)<<endl;cout<<"sizeof(B) = "<<sizeof(B)<<endl;return0;}

结果揭晓：

• sizeof(A)=1
• sizeof(B)=8(32位系统下是4)

为什么？

• 类A虽然有成员函数，但成员函数是不占对象内存空间的（它们存在代码段）。空类为了占位，编译器会给它分配1字节。
• 类B也是“空”的，只有一个函数，但因为加了virtual，编译器悄悄地在对象内部塞了一个指针。

这个指针，就是我们今天的主角——虚表指针（Virtual Pointer, 简称 vptr）。

2. 揭秘核心机制：虚函数表（vtable）与虚表指针（vptr）

对于初学者来说，这确实是理解C++多态最“劝退”的地方。但别急，我们把它们拆解开来看。

2.1 什么是虚函数表 (vtable)？

当编译器发现一个类中包含虚函数（或者是继承自包含虚函数的基类）时，它会为这个类（注意是类，不是对象）生成一张表。
这张表本质上是一个函数指针数组，数组里存放着该类所有虚函数的地址。

2.2 什么是虚表指针 (vptr)？

既然类有了表，那对象怎么找到这张表呢？
编译器会在实例化对象时，在对象的内存布局的最前面（通常是开头，取决于编译器实现）自动添加一个指针，指向该类的虚函数表。这个指针就是vptr。

内存布局示意图：

对象 obj 的内存布局: +----------------------+ | vptr (8 bytes) | ----------> +----------------------------+ +----------------------+ | Base::vtable | | member var 1 | +----------------------------+ +----------------------+ | [0] &Base::func1 | | member var 2 | | [1] &Base::func2 | +----------------------+ +----------------------------+

2.3 动态绑定的全过程

当我们使用基类指针调用虚函数时，编译器并没有像调用普通函数那样直接把函数地址写死（静态绑定），而是插入了一段“查表”的代码。

Base*ptr=newDerived();ptr->func();

这段代码在运行时经历了以下步骤（这是多态生效的关键！）：

1. 取指针：通过ptr找到对象的首地址。
2. 找vptr：读取对象首地址处的vptr。
3. 查vtable：通过vptr找到该对象所属类（Derived）的vtable。
4. 调函数：从vtable中取出对应的函数地址（例如第0个位置），然后跳转执行。

这就是为什么多态叫“动态绑定”——直到程序运行起来，顺藤摸瓜找到了虚表，才知道具体执行哪个函数。

3. 继承中的虚表变换（重写的本质）

当我们进行派生时，编译器是如何处理这张表的呢？这里体现了override（重写）的本质。

假设我们有如下关系：

classBase{public:virtualvoidfunc1(){cout<<"Base::func1"<<endl;}virtualvoidfunc2(){cout<<"Base::func2"<<endl;}};classDerived:publicBase{public:// 重写了 func1virtualvoidfunc1(){cout<<"Derived::func1"<<endl;}// 没重写 func2};

编译器构建Derived的虚表时，遵循以下规则：

1. 拷贝：先将基类Base的虚表内容拷贝一份过来。
2. 覆盖：如果派生类重写了某个虚函数（如func1），则用派生类自己的函数地址覆盖掉表中原有的基类函数地址。
3. 追加：如果派生类定义了新的虚函数，则将其地址添加到表的末尾。

小结：所谓的“重写”，在底层其实就是替换了虚表中对应位置的函数指针。

4. 经典面试题：为什么析构函数必须是虚函数？

这绝对是面试中出现频率Top 3的问题！

4.1 场景复现

如果我们用基类指针指向派生类对象，然后delete这个指针：

classBase{public:// 注意：这里没有加 virtual~Base(){cout<<"Delete Base"<<endl;}};classDerived:publicBase{public:~Derived(){cout<<"Delete Derived"<<endl;}};intmain(){Base*p=newDerived();deletep;// 灾难发生了！return0;}

4.2 运行结果与分析

输出：

Delete Base

问题：Derived的析构函数根本没执行！如果Derived里申请了堆内存，这里就造成了内存泄漏。

原因：因为~Base()不是虚函数，编译器进行的是静态绑定。编译器看到p是Base*类型，就直接生成了调用Base::~Base()的指令，完全不管它实际指向的是什么对象。

4.3 修正方案

只要将基类的析构函数加上virtual：

virtual~Base(){cout<<"Delete Base"<<endl;}

此时delete p会变成动态绑定，通过vptr找到Derived的析构函数先执行，然后编译器会自动插入代码调用基类的析构函数，保证清理顺序正确（先子后父）。

金科玉律：只要一个类可能被继承，且可能通过基类指针删除派生类对象，其析构函数必须声明为virtual。

5. 纯虚函数与抽象类

有时候，基类并不知道该怎么实现某个函数（比如“图形”类的“计算面积”函数），这时候就可以使用纯虚函数。

classShape{public:// 纯虚函数，也就是接口定义virtualdoublegetArea()=0;};

特点对比表

6. 避坑指南：那些关于虚函数的“反直觉”陷阱

虽然虚函数很强大，但也有它无能为力，甚至会“坑”你的时候。

6.1 构造函数中调用虚函数

千万不要在构造函数或析构函数中调用虚函数！

classBase{public:Base(){func();// 危险！}virtualvoidfunc(){cout<<"Base::func"<<endl;}};classDerived:publicBase{public:virtualvoidfunc(){cout<<"Derived::func"<<endl;}};

当你执行Derived d;时，会先调用Base的构造函数。此时，Derived的部分还没有初始化，对象的类型在编译器眼里暂时还是Base。
因此，Base构造函数里调用的func()永远是Base::func()，多态失效了。

6.2 默认参数是静态绑定的

classBase{public:virtualvoidshow(intx=10){cout<<"Base: "<<x<<endl;}};classDerived:publicBase{public:virtualvoidshow(intx=20){cout<<"Derived: "<<x<<endl;}};intmain(){Base*p=newDerived();p->show();// 猜猜输出什么？}

输出结果：Derived: 10

原因：这确实很反直觉！

• 函数执行是动态的（调用了Derived的函数体）。
• 默认参数是静态的（编译期根据指针类型Base*决定的）。
  所以你得到了一个“缝合怪”：Derived的逻辑，加上Base的默认参数。切记：绝不要重新定义继承而来的默认参数值。

# 总结

今天我们从编译器的角度重新审视了虚函数，是不是感觉清晰了很多？不再是死记硬背语法，而是理解了底层的流动。

这篇文章我们主要讲了：

• 内存变化：包含虚函数的类会多出一个vptr指针，导致对象大小增加。
• 底层机制：多态是通过vptr（查表指针）和vtable（函数地址表）配合实现的动态绑定。
• 重要规则：基类析构函数必须是virtual，以防内存泄漏。
• 避坑细节：构造函数中多态失效，以及默认参数静态绑定的陷阱。

C++的魅力就在于此，越钻研底层，越能体会到设计的精妙。如果你觉得这篇文章对你有帮助，别忘了三连支持一下小瓶子哦！