C++ 抽象类与多态原理深度解析：从纯虚函数到虚表机制（附高频面试题）

草莓熊Lotso2025-11-13 8:52


🔥草莓熊Lotso： 个人主页
❄️个人专栏: 《C++知识分享》 《Linux 入门到实践：零基础也能懂》
✨生活是默默的坚持，毅力是永久的享受！

🎬 博主简介：

文章目录

  • 前言：
  • [一. 纯虚函数与抽象类：强制接口规范的"契约"](#一. 纯虚函数与抽象类：强制接口规范的“契约”)
    • [1.1 纯虚函数：没有实现的 "接口声明"](#1.1 纯虚函数：没有实现的 “接口声明”)
    • [1.2 抽象类：包含纯虚函数的 "不可实例化类"](#1.2 抽象类：包含纯虚函数的 “不可实例化类”)
  • [二. 多态的底层原理：虚表指针与虚函数表](#二. 多态的底层原理：虚表指针与虚函数表)
    • [2.1 虚表指针（vfptr）：对象中的 "导航器"](#2.1 虚表指针（vfptr）：对象中的 “导航器”)
    • [2.2 多态的实现原理](#2.2 多态的实现原理)
    • [2.3 虚函数表（vtable）：存储虚函数地址的 "数组"](#2.3 虚函数表（vtable）：存储虚函数地址的 “数组”)
    • [2.4 动态绑定与静态绑定](#2.4 动态绑定与静态绑定)
  • [三. 关键问题辨析与总结](#三. 关键问题辨析与总结)
    • [3.1 虚函数存在哪里？虚表又存在哪里？](#3.1 虚函数存在哪里？虚表又存在哪里？)
    • [3.2 实战注意事项：](#3.2 实战注意事项：)
  • [四. 多态考察的一些常见问题(重点，面试高频题)](#四. 多态考察的一些常见问题(重点，面试高频题))
  • 结尾：

前言：

在 C++ 多态体系中，纯虚函数与抽象类是实现 "接口规范" 的核心工具，而虚函数表（vtable）与虚表指针（vfptr）则是多态底层实现的关键。本文将基于实战代码，从纯虚函数与抽象类的定义、使用场景入手，逐步拆解多态的底层原理 ------ 包括虚表指针的存在性、虚函数表的结构与存储位置，最终帮你打通 "多态怎么用" 到 "多态如何实现" 的认知链路。

一. 纯虚函数与抽象类：强制接口规范的"契约"

在实际开发中，我们经常需要定义一个"只规定行为，不提供具体实现"的类。C++ 通过纯虚函数 和抽象类实现这种 "接口契约"。

本文代码示例所需头文件：

cpp 复制代码 
#include<iostream>
using namespace std;

代码仓库 ：多态收尾- Gitee.com

1.1 纯虚函数：没有实现的 "接口声明"

在虚函数的声明后加=0，该函数即为纯虚函数。纯虚函数无需在基类中实现（语法上允许实现，但无实际意义，因为会被派生类重写），其核心作用是 "强制派生类必须重写该函数"。

1.2 抽象类：包含纯虚函数的 "不可实例化类"

包含纯虚函数的类称为抽象类，它有两个关键特性：

  • 无法直接实例化对象（编译器会报错）；
  • 派生类若未重写基类的所有纯虚函数，自身也会成为抽象类，同样无法实例化。

有了上面的知识储备，我们来看下代码示例吧：

cpp 复制代码 
// 抽象类：包含纯虚函数Drive()
class Car {
public:
    // 纯虚函数：只声明接口，不提供实现
    virtual void Drive() = 0; 
};

// 派生类Benz：重写纯虚函数，成为"具体类"
class Benz :public Car {
public:
    // 必须重写Drive()，否则Benz也是抽象类
    virtual void Drive() {
        cout << "Benz-舒适" << endl; 
    }
};

// 派生类BMW：重写纯虚函数，成为"具体类"
class BMW :public Car {
public:
    virtual void Drive() {
        cout << "BMW-操控" << endl; 
    }
};

int main() {
    // 抽象类无法实例化对象
    // Car car; 

    // 用抽象类指针指向派生类对象（多态核心用法）
    Car* pBenz = new Benz;
    pBenz->Drive();  // 多态调用：输出"Benz-舒适"

    Car* pBMW = new BMW;
    pBMW->Drive();   // 多态调用：输出"BMW-操控"
    return 0;
}

二. 多态的底层原理：虚表指针与虚函数表

当我们用基类指针调用派生类的虚函数时，编译器如何 "知道" 该调用哪个类的函数？答案藏在虚表指针（vfptr） 和虚函数表（vtable） 中 ------ 这是 C++ 实现动态绑定（运行时多态）的核心机制。

2.1 虚表指针（vfptr）：对象中的 "导航器"

首先通过下面这个题目来验证一下虚表指针的存在

下面编译为32位程序的运行结果是什么（D）

A. 编译报错 B. 运行报错 C. 8 D. 12

cpp 复制代码 
class Base
{
public:
	// 虚函数：触发编译器生成虚表指针
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Func2()" << endl;
	}
	 // 普通函数
	void Func3()
	{
		cout << "Func3()" << endl;
	}
protected:
	int _b = 1;
	char _ch = 'x';
};
int main()
{
	Base b;
	//除了我们能看到的_b和_ch，其实有虚函数的类就会有一个虚函数表指针(32位下4字节,64位下8字节)
	//因为⼀个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。
	cout << sizeof(b) << endl;//32位：4+4+1->12
	// 输出结果：32位环境下为12字节，64位环境下为16字节
	return 0;
}


关键结论：

  • 只要类中包含虚函数（或继承自含虚函数的类），该类的对象就会额外存储一个虚表指针；
  • 虚表指针通常位于对象内存的最前端（不同编译器可能有差异），其作用是 "指向该类的虚函数表"；
  • 同类型的对象共用一张虚函数表，但每个对象都有独立的虚表指针（指向同一张虚表）。

2.2 多态的实现原理

从底层的角度Func函数中ptr->BuyTicket()，是如何作为ptr指向Person对象调用Person::BuyTicket，ptr指向Student对象调用Student::BuyTicket的呢？通过下图我们可以看到，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。第⼀张图，ptr指向的Person对象，调用的是Person的虚函数；第二张图，ptr指向的Student对象，调用的是Student的虚函数。


cpp 复制代码 
class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:
	string _name;
};

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:
	string _id;
};

void Func(Person ptr)
{
	// 这里可以看到虽然都是Person指针Ptr在调用BuyTicket
	// 但是跟ptr没关系，而是由ptr指向的对象决定的。
	ptr.BuyTicket();
}

int main()
{
	// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
	// 多态也会发⽣在多个派⽣类之间。
	Person ps;
	Student st;
	
	Func(ps);
	Func(st);
	
		////这三个的虚函数表是一样的，同类型的对象共用一虚表
	//Person p1;
	//Person p2;
	//Person p3;

	return 0;
}

2.3 虚函数表（vtable）：存储虚函数地址的 "数组"

虚函数表（简称 "虚表"）是编译器为每个含虚函数的类生成的一张 "虚函数指针数组"，数组中存储的是该类所有虚函数的地址。其结构与生成规则如下：

  • 基类虚表 ：存储基类所有虚函数的地址（如Base类的虚表存储Func1和Func2的地址）；

  • 派生类虚表：

    • 首先继承基类虚表的所有内容；
    • 若派生类重写了基类的虚函数，会用派生类自身的虚函数地址 "覆盖" 基表中 对应的位置；
    • 派生类新增的虚函数，其地址会追加到虚表的末尾；

  • 虚表结尾标记 ：部分编译器（如 VS）会在虚表末尾添加0x00000000作为结束标记（g++ 无此标记，C++ 标准未强制规定）。

  • 注意：同类型的对象共用同一张虚表，不同类型的对象都有各自独立的虚表。

cpp 复制代码 
class Base {
	public:
		virtual void func1() { cout << "Base::func1" << endl; }
		virtual void func2() { cout << "Base::func2" << endl; }
		 // 普通函数：不存入虚表
		void func5() { cout << "Base::func5" << endl; }
	protected:
		int a = 1;
	};
	
	class Derive : public Base
	{
	public:
		// // 重写基类的func1：会覆盖虚表中func1的地址
		virtual void func1() { cout << "Derive::func1" << endl; }
		// 派生类新增虚函数：会追加到虚表末尾
		virtual void func3() { cout << "Derive::func1" << endl; }
		 // 普通函数：不存入虚表
		void func4() { cout << "Derive::func4" << endl; }
	protected:
		int b = 2;
	};

	int main()
	{
		Base b;
		Derive d;
	
		return 0;
	}


2.4 动态绑定与静态绑定

  • 对不满足多态条件(指针或者引用+调用虚函数)的函数调用在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
  • 满足多态条件的函数调用是在运行时绑定，也就是运行时到指定对象的虚函数表中找到调用函数的地址，也叫做动态绑定。

当用基类指针调用虚函数时，编译器会按以下步骤完成 "动态绑定"（运行时确定调用的函数）：

  • 获取虚表指针：从基类指针指向的对象中，取出虚表指针（vfptr）；
  • 查找虚表：通过虚表指针找到该对象所属类的虚函数表（vtable）；
  • 定位函数地址：在虚表中找到目标虚函数对应的地址（若派生类重写过，此处就是派生类函数地址）；
  • 调用函数：通过找到的函数地址，调用对应的虚函数。

以之前的 "买票" 场景为例，流程如下：

bash 复制代码 
// 基类指针指向派生类对象
Person* ptr = new Student;
// 动态绑定流程：
1. 从ptr指向的Student对象中，取出vfptr；
2. 通过vfptr找到Student类的虚表；
3. 在虚表中找到BuyTicket对应的地址（Student::BuyTicket的地址）；
4. 调用该地址对应的函数，输出"买票-打折"。

三. 关键问题辨析与总结

3.1 虚函数存在哪里？虚表又存在哪里？

  • 虚函数 ：与普通函数一样，编译后是一段机器指令，存储在代码段；虚表中仅存储虚函数的 "地址"，而非函数本身；
  • 虚表 ：本质是 "存储虚函数地址的指针数组"，在 VS 等编译器中存储在代码段（常量区）（因内容不可修改），C++ 标准未强制规定存储位置，不同编译器可能有差异。
cpp 复制代码 
int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);

	Base b;
	Derive d;

	printf("Base虚函数表地址:%p\n", *((int*)&b));
	printf("Derive虚函数表地址:%p\n", *((int*)&d));

	printf("虚函数地址:%p\n", &Base::func1);
	printf("普通函数地址:%p\n", &Base::func5);
}

运行结果 ：

栈:010FF954

静态区:0071D000

堆:0126D740

常量区:0071ABA4

Person虚表地址:0071AB44

Student虚表地址:0071AB84

虚函数地址:00711488

普通函数地址:007114BF

3.2 实战注意事项：

  • 抽象类只能作为基类指针 / 引用使用，不可直接实例化；
  • 抽象类无法实例化，派生类必须重写所有纯虚函数才能成为 "具体类"；
  • 虚表指针会增加对象的内存开销（32 位下 4 字节，64 位下 8 字节）；
  • 虚函数调用比普通函数多一次 "地址查找"，存在微小性能损耗，但通常可忽略（多态带来的灵活性远大于性能损失）。

四. 多态考察的一些常见问题(重点，面试高频题)

1. 面向对象的三大特性(这里重点讲讲什么是多态)

  • 封装：将数据和操作数据的方法封装在一起，隐藏对象的内部实现细节，仅对外暴露公共接口，降低耦合性(eg:迭代器的实现)
  • 继承：子类继承父类的属性和方法，子类可以直接使用父类的非私有成员和方法，实现代码的复用，同时子类可以对父类的方法进行扩展和重写
  • 多态：多态分为静态多态(编译时多态)和动态多态(运行时多态)，静态多态比如函数的重载，模板。我们可以通过传不同的参数达到不同的效果。动态时多态就要求有继承关系，用基类的指针或者引用去调用虚函数，且派生类对基类的虚函数完成了重写，根据基类的指针指向的对象去调用对应的方法，做到不同对象执行不同逻辑。(eg.动物叫声的例子，不同的对象发出不同的叫声)

2. 什么是重载，重写(覆盖)，重定义(隐藏)？

  • 重载：同一类中(同一作用域中)，函数名相同，参数列表（参数类型、个数、顺序）不同，返回值类型可以相同也可以不同
  • 重写(覆盖) ：子类继承父类后(不同作用域)，对父类的虚函数进行重新实现，函数名、参数列表、返回值类型（协变情况除外）完全相同。
  • 重定义(隐藏)：(不同作用域)子类中定义了与父类同名(只需要同名就可以)的非虚函数，隐藏父类的该函数。
特性 定义 示例
重载 同一类中，方法名相同，参数列表（参数类型、个数、顺序）不同，与返回值类型无关 类中add(int a, int b)和add(double a, double b)
重写（覆盖） 子类继承父类后，对父类的虚函数进行重新实现，方法名、参数列表、返回值类型（协变情况除外）完全相同 父类Animal的虚函数makeSound()，子类Dog重写为void makeSound() { cout << "汪汪" << endl; }
重定义（隐藏） 子类中定义了与父类同名的非虚函数，隐藏父类的该函数 父类有func()，子类也定义func()，子类对象调用func()时执行子类的，父类对象调用执行父类的

3. 多态的实现原理？
答： 多态通过 虚函数表（vtable）和虚函数指针（vptr） 实现。每个包含虚函数的类都有一个虚函数表，表中存储着该类所有虚函数的地址。每个对象都有一个虚函数指针，指向所属类的虚函数表(相同类型的对象指向同一张虚函数表)。当通过父类指针或者引用调用虚函数时，程序会根据指向的实际对象类型，通过其虚函数指针找到虚函数表，再找到对应的虚函数地址并调用，从而实现运行时的多态。
4. inline函数可以是虚函数吗？inline属性和虚函数属性能同时存在吗？
答 ：可以是虚函数，从语法上看，inline函数可以声明为虚函数，但实际上编译器会忽略inline属性(inline一般展开是不需要地址的)，将其当作普通虚函数处理。因为虚函数要放在虚表中去，两者机制冲突，也就是说inline属性和虚函数属性是不同时存在的。
5. 静态成员可以是虚函数吗？
答 ：不能，静态成员函数属于类，不属于某个对象，没有this指针，而虚函数的调用需要通过对象的虚函数指针来实现，所以静态成员函数不能是虚函数。
6. 构造函数可以是虚函数吗？
答 ：不可以。因为对象中的虚函数指针是在构造函数初始化列表阶段才初始化的，所以构造函数不能是虚函数。
7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

  • 析构函数可以是虚函数。
  • 场景：当存在继承关系，且需要通过父类指针删除子类对象时，为了确保子类的析构函数被调用，需要将父类的析构函数声明为虚函数。例如 ：父类Base，子类Derived，若用Base* p = new Derived(); delete p;，如果Base的析构函数不是虚函数，只会调用Base的析构函数，导致子类资源未释放；若为虚函数，则会先调用Derived的析构函数，再调用Base的析构函数。

8. 对象访问普通函数快还是虚函数更快？
答：首先如果是普通对象调用的话两者是一样快的，但如果是基类的指针或者引用去调用，且构成了多态调用，则调用的普通函数更快，运行时调用虚函数需要到虚函数表中去查找，有一定开销。

调用场景 普通函数调用机制 虚函数调用机制 性能差异根源
普通对象调用 编译时直接绑定函数地址，直接跳转执行 编译时直接绑定函数地址，直接跳转执行 无差异
基类指针/引用多态调用 编译时直接绑定函数地址，直接跳转执行 运行时通过vptr找vtable，再找函数地址执行 虚函数多了查表的运行时开销

9. 虚函数表是在什么阶段生成的，存在哪里的？
答 ：虚函数表是在编译阶段 生成的，一般情况下是存在代码段(常量区)的。
10. C++菱形继承的问题？虚继承的原理？
答：菱形继承会导致数据冗余和二义性 的问题，虚继承则是通过虚基类指针和虚基表 (不要把虚函数表，虚函数指针和虚基表，虚基类指针搞混了) 实现的中间基类在继承时顶层基类时声明为虚继承，这样可以保证顶层基类的成员只会有一份，解决了数据冗余和二义性的问题。
11. 什么是抽象类？抽象类的作用？
答 ： 包含纯虚函数（形如virtual void func() = 0;）的类，无法实例化对象。抽象类的作用是 作为接口规范，强制子类必须重写实现纯虚函数

结尾：

html 复制代码 
🍓 我是草莓熊 Lotso！若这篇技术干货帮你打通了学习中的卡点：
👀 【关注】跟我一起深耕技术领域，从基础到进阶，见证每一次成长
❤️ 【点赞】让优质内容被更多人看见，让知识传递更有力量
⭐ 【收藏】把核心知识点、实战技巧存好，需要时直接查、随时用
💬 【评论】分享你的经验或疑问（比如曾踩过的技术坑？），一起交流避坑
🗳️ 【投票】用你的选择助力社区内容方向，告诉大家哪个技术点最该重点拆解
技术之路难免有困惑，但同行的人会让前进更有方向～愿我们都能在自己专注的领域里，一步步靠近心中的技术目标！

结语：通过抽象类，我们能定义清晰的接口契约；通过虚表机制，C++ 实现了 "运行时动态绑定" 的多态能力。理解这两者，不仅能正确使用多态，更能在复杂场景中（如框架设计、模块扩展）写出更灵活、可维护的 C++ 代码。

✨把这些内容吃透超牛的！放松下吧✨ ʕ˘ᴥ˘ʔ づきらど

相关推荐
XINVRY-FPGA2 小时前
5CEFA9F23I7N Altera CycloneV E（Enhanced）FPGA
人工智能·嵌入式硬件·计算机视觉·fpga开发·硬件工程·dsp开发·fpga
Rock_yzh2 小时前
LeetCode算法刷题——49. 字母异位词分组
数据结构·c++·学习·算法·leetcode·职场和发展·哈希算法
小欣加油2 小时前
leetcode 2654 使数组所有元素变成1的最少操作次数
数据结构·c++·算法·leetcode·职场和发展
Wayfreem2 小时前
Spring AI Alibaba 学习之最简单的快速入门
人工智能·学习·spring
再玩一会儿看代码2 小时前
Ken的Java学习之路——Java中关于面向对象
java·开发语言·经验分享·python·学习
迦蓝叶2 小时前
通过 HelloWorld 深入剖析 JVM 启动过程
java·开发语言·jvm·aot·启动过程·helloword·leyden
shayudiandian2 小时前
图像分类深度学习
人工智能
q***31892 小时前
深入解析Spring Boot中的@ConfigurationProperties注解
java·spring boot·后端
王哈哈^_^2 小时前
【完整源码+数据集】车牌数据集，yolov8车牌检测数据集 7811 张，汽车车牌识别数据集，智慧交通汽车车牌识别系统实战教程
人工智能·深度学习·yolo·目标检测·计算机视觉·毕业设计·智慧城市
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Labelme从安装到标注：零基础完整指南07智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践08BongoCat - 跨平台键盘猫动画工具09《大数据技术原理与应用》实验报告三 熟悉HBase常用操作10全面评测 | Photoshop 2026 新特性深度解析与实测体验