C++多态：理解面向对象的“一个接口，多种实现”

学习编程的gas2025-08-14 13:14

目录

多态的概念

多态的定义和实现

虚函数重写

函数重载、重写、重定义的对比

[关键字override 和 final](#关键字override 和 final)

抽象类

探究多态原理

虚函数表

动态绑定与静态绑定

单继承和多继承中的虚表

C++是面向对象的语言，该语言四大特性封装、继承、多态和抽象。在上一篇小编编辑了C++类的继承文章，而这篇文章主要是对多态的理解，多态是什么？如何实现多态？在实现多态时需要注意什么细节等问题在文章中都会解答，欢迎各位阅读！

多态的概念

什么是多态呢？多态就是多种形态，准确来说就是去完成某个行为，不同对象去执行会产生不同的状态。例如我们在12306上买票，普通人买票是正常价，而学生买票可以是学生价，不同的对象去完成这个买票事情，支付的价格却是不一样的。而C++有多态这一特性就更加贴合现实生活，一件事不同的人去完成就会展现不同的状态。

多态的定义和实现

如何来实现多态？实现多态的条件又是什么呢？实现多态需要在继承体系中，多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

要实现多态的条件在继承体系中有两个：1、必须通过基类的指针或者引用调用虚函数

2、被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

代码示例：

cpp 复制代码 
class A {
public:
	virtual void test()
	{
		cout << "A::test()" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test()
	{
		cout << "B::test()" << endl;
	}
protected:
	int _b = 0;
};

void test1(A& a)
{
	a.test();
}

int main()
{
	A aa;
	B bb;
	test1(aa);
	test1(bb);
	return 0;
}

通过基类的指针或者引用来调用虚函数，学习完继承也知道子类是可以切片赋值给父类的指针或者引用的，切片赋值为什么就可以去调用子类的函数呢？虚函数又是什么呢？虚函数的重写又是什么呢？我们先来说说什么是虚函数，虚函数即被virtual修饰的类成员函数称为虚函数。在上面一段代码中，A类中test（）函数就是虚函数，在B类中的test函数便是对虚函数的重写。

虚函数重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的 返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

代码示例：

cpp 复制代码 
class A {
public:
	virtual void test()
	{
		cout << "A::test()" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test()
	{
		cout << "B::test()" << endl;
	}
protected:
	int _b = 0;
};

虚函数重写的条件是三同+虚函数，但是有些例外：协变 和析构函数的重写

什么是协变呢？派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指 针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

代码示例：

cpp 复制代码 
class A{};
class B : public A {};
class Person {
public:
 virtual A* f() {return new A;}
};
class Student : public Person {
public:
 virtual B* f() {return new B;}
};

在派生类中虚函数重写可以不加virtual关键字，但是不建议这样做，添加关键字更方便理解。

还有一个例外是析构函数的重写 ，这里就有一个疑问了，析构函数不是~+类名吗？怎么会构成析构函数重写呢？而重写的条件又是返回类型相同、函数名相同、参数相同，怎么看析构函数也构不成重写。其实析构函数在编译器中进行了处理，都处理成同一个名字**destructor。**如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。

代码示例：

cpp 复制代码 
class A {
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual ~B()
	{
		cout << "~B()" << endl;
	}
protected:
	int _b = 0;
};

int main()
{
	A* p1 = new A;
	A* p2 = new B;

	delete p1;
	delete p2;
	
	return 0;
}

运行结果：

函数重载、重写、重定义的对比

关键字override 和 final

这两个关键字final是检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错，override是让该虚函数不能被重写。

final代码示例：

cpp 复制代码 
class A {
public:
	virtual void test() final
	{
		cout << "A::test()" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test()
	{
		cout << "B::test()" << endl;
	}
protected:
	int _b = 0;
};

override代码示例：

cpp 复制代码 
class A {
public:
	virtual void test() 
	{
		cout << "A::test()" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test() override
	{
		cout << "B::test()" << endl;
	}
protected:
	int _b = 0;
};

抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口 类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生 类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实 现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成 多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

探究多态原理

C++是如何来实现多态的，是和继承一样有一个指针指向一个虚表吗？我们知道再继承中菱形虚拟继承中有虚基表，存储着偏移量，那么在多态中是否也有这样的结构呢？让我们一起来看看吧！

虚函数表

在继承中有虚基表，而在多态里就是虚函数表，在有虚函数的基类中有一个指针指向一张虚函数表，对于该类的子类如果对虚函数进行了重写，那么在子类中的指针指向的虚函数表是拷贝了父类的虚函数表，由于进行了虚函数重写（覆盖），也就将父类的虚函数进行了覆盖，从而达到不同对象去完成这一行为展现出不同状态。

代码示例：

cpp 复制代码 
class A {
public:
	virtual void test() 
	{
		cout << "A::test()" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test() 
	{
		cout << "B::test()" << endl;
	}
protected:
	int _b = 0;
};

int main()
{
	A aa;
	B bb;

	return 0;
}

通过观察测试我们发现b对象是8bytes，除了_a成员，还多一个__vfptr放在对象的前面(注意有些 平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代 表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数 的地址要被放到虚函数表中，虚函数表也简称虚表。

而在派生类中bb对象继承了A，所以在bb对象中包含A的成员和函数，但是A类的成员函数时虚函数，B类又对虚函数进行重写，因为虚函数指针指向的是重写的虚函数。重写是语法的叫法，覆盖是原理层的叫法。

如果我们在A类中添加一个虚函数但是不进行重写和一个普通函数，观察虚表中是否有这两个函数？

代码示例：

cpp 复制代码 
class A {
public:
	virtual void test() 
	{
		cout << "A::test()" << endl;
	}

	virtual void test1()
	{
		cout << "1111" << endl;
	}

    void test2()
	{
		cout << "2222" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test() 
	{
		cout << "B::test()" << endl;
	}

	
protected:
	int _b = 0;
};

int main()
{
	A aa;
	B bb;

	return 0;
}

调试观察：

观察内存：

从这里我们就可以得出在基类中，虚函数是会放进虚表中的，而普通函数不会。虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

总结一下派生类的虚表生成：1、先将基类中的虚表内容拷贝一份到派生类虚表中 2、如果派生 类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 3、派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

那么虚函数存放在哪里呢？虚表有存放在哪里？

虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。

虚表存放在哪里呢？我们通过一段代码来验证一下：

代码示例：

cpp 复制代码 
class A {
public:
	virtual void test() 
	{
		cout << "A::test()" << endl;
	}

	virtual void test1()
	{
		cout << "1111" << endl;
	}

	void test2()
	{
		cout << "2222" << endl;
	}
protected:
	int _a = 0;
};

class B:public A
{
public:
	virtual void test() 
	{
		cout << "B::test()" << endl;
	}

	
protected:
	int _b = 0;
};


int main()
{
	//检验虚表存储在哪个区
	A aa;
	B bb;

	int a = 0;
	printf("栈：%p\n", &a);

	static int b = 0;
	printf("静态区：%p\n", &b);

	int* p = new int;
	printf("堆：%p\n", &p);

	const char* str = "hello";
	printf("常量区：%p\n", str);

	printf("虚表1:%p\n", *((int*)&aa));
	printf("虚表2:%p\n", *((int*)&bb));


	return 0;
}

运行结果：

通过运行结果观察，虚表1和虚表2的地址距离常量区是比其他三个区更近的，所以大家应该知道虚表存储在常量区。

动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态， 比如：函数重载

  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体 行为，调用具体的函数，也称为动态多态。

单继承和多继承中的虚表

在单继承中虚表会存储基类中的虚函数，不管子类是否重写虚函数，但是虚表不会存储普通函数，对于子类中的虚函数是否会存储到虚表中呢？

代码示例：

cpp 复制代码 
class A {
public:
	virtual void test()
	{
		cout << "A::test()" << endl;
	}

protected:
	int _a = 0;
};

class B :public A
{
public:
	virtual void test()
	{
		cout << "B::test()" << endl;
	}

	virtual void test1()
	{
		cout << "B::test1()" << endl;
	}

	virtual void test2()
	{
		cout << "B::test2()" << endl;
	}
protected:
	int _b = 0;
};

int main()
{
	A aa;
	B bb;

	return 0;
}

监视窗口：

在监视窗口中并未看到虚表中存储了B类中的虚函数，难道真的是这样吗？我们还可以从内存中观察：

通过内存窗口可以看到在nullptr之前有三个函数指针，说明子类中的虚函数也是会存储到虚表中的。

多继承中子类的未重写的虚函数存放在那个虚表中呢？

代码示例：

cpp 复制代码 
class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }

	int b1;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }

	int b2;
};
class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }

	int d1;
};

typedef void(*VFPTR) ();

void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

运行结果：

从运行结果可以看出多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

相关推荐
Warren9813 分钟前
Java Record 类 — 简化不可变对象的写法
java·开发语言·jvm·分布式·算法·mybatis·dubbo
幼稚园的山代王31 分钟前
Kotlin数据类型
android·开发语言·kotlin
青春不流名1 小时前
-bash: ll: 未找到命令
开发语言·bash
菜就多练，以前是以前，现在是现在1 小时前
Codeforces Round 1042 (Div. 3)
c++·算法
啃火龙果的兔子2 小时前
Form.Item中判断其他Form.Item的值
开发语言·前端·javascript
EndingCoder2 小时前
Next.js 中间件：自定义请求处理
开发语言·前端·javascript·react.js·中间件·全栈·next.js
FirstFrost --sy2 小时前
C++ stack and queue
开发语言·c++·queue·stack·priority_queue
墨城之左2 小时前
低版本 IntelliJ IDEA 使用高版本 JDK 语言特性的问题
java·开发语言·intellij-idea·jdk21
别来无恙1493 小时前
Java Web开发：Session与Cookie详细入门指南
java·开发语言
热门推荐
01UV安装并设置国内源02全球最强模型Grok4，国内已可免费使用！（附教程）032025最新国内服务器可用docker源仓库地址大全（2025年8月更新）04Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code05TRAE Rules 实践：为项目配置 6A 工作流06[已解决]VSCode右键菜单消失恢复07KGG转MP3工具|非KGM文件|解密音频08GPT-5 使用限制与国内升级全攻略（免费 / Plus / Pro）【2025 最新】09Cursor 终端“卡死/无响应”问题的解法10OpenAI重返开源！GPT-OSS本地部署完全指南