当前位置：首页 > news >正文

【C++】多态深度解析：虚函数表与动态绑定的奥秘

news 2025/10/23 9:36:02

在这里插入图片描述

💻作者简介：曾与你一样迷茫，现以经验助你入门 C++。
💡个人主页：@笑口常开xpr 的个人主页
📚系列专栏：C++ 炼魂场：从青铜到王者的进阶之路
✨代码趣语：多态就像遥控器，按同一个按钮，不同设备做不同事，因为每个设备都有自己的 “功能表”（虚表）。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述

文章目录

多态
- 定义
- 虚函数
- 虚函数的重写
- - 定义
  - 特殊情况
- 构成条件
- - 条件
  - 代码展示
  - 结论
- override 和 final
- 重载、覆盖(重写)、隐藏(重定义)的对比
抽象类
多态的原理
- 虚函数表
- 结论
- 动态绑定与静态绑定
多继承中的虚函数表
总结

多态是 C++ 面向对象的核心特性，是实现代码灵活扩展的关键，但学习中常遇 “概念混淆、原理抽象” 问题。本文从虚函数、重写规则等基础入手，拆解多态构成条件，深入虚表与动态绑定底层，帮你从 “会用” 到 “理解” 多态。

多态

定义

多态就是多种形态，当不同的对象去完成某个行为，会产生出不同的状态。

虚函数

被 virtual 修饰的类 成员函数 称为虚函数。

class Person 
{
public://虚函数virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

全局函数不能构成虚函数，虚函数必须是成员函数。

virtual void BuyTicket()
{cout << "买票-全价" << endl;
}

在这里插入图片描述

虚函数的重写

定义

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

特殊情况

重写的条件是虚函数 + 三同（返回值类型、函数名字、参数列表）。

子类可以不加 virtual，父类必须加，在这里建议都加上。原因是子类已经继承了父类的虚函数特性。
协变，返回的值可以不同，但是要求返回值必须是父子关系指针和引用，不一定是当前父子关系，父子必须同时是指针或者引用。协变的使用场景很少。

协变

#include<iostream>
using namespace std;
class Person 
{
public:virtual Person* BuyTicket(){ cout << "买票-全价" << endl;return 0;}
};
class Student : public Person 
{
public:virtual Student* BuyTicket() { cout << "买票-半价" << endl; return 0;}/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{p.BuyTicket();
}
int main()
{Person ps;Student st;Func(ps);Func(st);return 0;
}

在这里插入图片描述
3. 析构函数加 virtual，是虚函数重写，因为类析构函数都被处理成 destructor 这个统一的名字，让它们构成重写。
情景 1

#include<iostream>
using namespace std;
class Person 
{
public:virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person 
{
public:virtual ~Student() { cout << "~Student()" << endl; }
};
int main()
{Person p;Student s;return 0;
}

在这里插入图片描述
这里父类被析构了两次是因为父类调用完成后被析构。然后子类对象中有父类对象，先析构子类中的父类，然后析构子类。
情景 2
析构函数是虚函数吗？为什么要一定是虚函数？

#include<iostream>
using namespace std;
class Person 
{
public:~Person() { cout << "~Person()" << endl; }
};
class Student : public Person 
{
public:~Student() { cout << "~Student()" << endl; delete[] ptr;}
private:int* ptr = new int[10];
};
int main()
{//Person p;//Student s;Person* p = new Person;delete p;p = new Student;delete p;//p->destructor() + operator delete(p)//这里期望p->destructor()是一个多态调用,而不是普通调用return 0;
}

在这里插入图片描述
         这段代码中只调用了父类的析构函数，没有调用子类的析构函数，多态调用看的是指向的对象。普通对象看当前调用对象的类型。在 p = new Student; 这句代码中，p 的类型是 Person*，这里 p 被当成了普通对象，没有调用子类的析构函数，而发生了内存泄漏。
         在 C++ 中，当通过基类指针删除派生类对象时，如果基类析构函数不是虚函数，只会调用基类析构函数，而不会调用派生类析构函数。所以，需要将析构函数改成重写防止内存泄漏。
         这里建议只要子类要继承父类，建议写出子类的析构函数，并将父子类前面加上 virtual 改成虚函数

情景 3
虚函数重写改变的是函数的实现内容。虚函数重写的本质是在派生类中，用一个新的函数体，替换掉基类中虚函数的实现。当通过基类指针或引用调用该虚函数时，会根据对象的实际类型（运行时类型）调用对应的派生类版本。

#include<iostream>
using namespace std;
class A
{
public:virtual void func(int val = 1) { std::cout << "A->" << val << std::endl;}virtual void test() { func();//this*->func(),this*指的是A*,调用的是父类的func函数}
};
class B : public A
{
public:void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{B* p = new B;p->test();return 0;
}

在这里插入图片描述
这里使用的是基类的函数名，派生类的函数体。这也就是为什么可以省略派生类的 virtual。

构成条件

条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。那么在继承中要构成多态还有两个条件：
（1）必须通过父类的指针或者引用调用虚函数。
为什么必须是父类的指针或引用？
在 C++ 中，动态绑定（多态）是通过虚函数表（vtable）和虚表指针（vptr） 实现的：

每个包含虚函数的类编译时会生成一张虚函数表（vtable），里面存放着虚函数的地址。
每个对象会有一个虚表指针（vptr），指向自己所属类的 vtable。
当你通过父类的指针或引用调用虚函数时，编译器会：
（1）找到该对象的 vptr
（2）根据 vptr 找到对应的 vtable
（3）在 vtable 中找到真正要调用的函数地址并执行。

这样，即使指针是父类型，但实际对象是子类型时，也会调用子类的虚函数。

为什么不能是子类？
如果你用子类指针，它只能指向子类对象，编译器在编译期就可以确定调用的是子类的函数（静态绑定），不需要动态绑定。多态的意义在于 用父类指针指向不同子类对象，调用同一个方法，行为不同。如果用子类指针，就失去了这种灵活性。

为什么不能是父类的对象？
如果你直接用父类对象，那它就是一个纯粹的父类对象，它的 vptr 指向父类的 vtable。
当你把子类对象赋值给父类对象时，会发生对象切片：

子类对象中属于父类的部分会被复制，子类特有的成员和 vptr 会被 “切掉”。
这个父类对象的 vptr 依然指向父类的 vtable，调用虚函数时只会调用父类版本。这就是为什么对象切片会破坏多态。
首先派生类会将父类的虚表拷贝下来，然后去重写覆盖对应的地址。虚函数表没有拷贝。
对象的切片和引用的切片是不同的。子类赋值给父类切片，不会拷贝虚表，如果拷贝虚表，则不能确定父类的对象中虚表是父类还是子类的虚函数。

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

代码展示

#include<iostream>
using namespace std;
class Person 
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl;}
};
class Student : public Person 
{
public://虚函数的重写virtual void BuyTicket() { cout << "买票-半价" << endl; }/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{p.BuyTicket();
}
int main()
{Person ps;Student st;Func(ps);Func(st);return 0;
}

在这里插入图片描述

结论

对象中不存在成员函数，只存在成员变量。
多态调用看的是指向的对象。普通对象看当前调用对象的类型。
2 个条件缺一不可。派生类发生了切片。

override 和 final

final：修饰虚函数，表示该虚函数不能再被重写。final 添加在基类后面。

#include<iostream>
using namespace std;
class Car
{
public:virtual void Drive() final {}
};
class Benz :public Car
{
public:virtual void Drive() { cout << "Benz-舒适" << endl;}
};
int main()
{Benz b;b.Drive();return 0;
}

在这里插入图片描述
override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

#include<iostream>
using namespace std;
class Car 
{
public:virtual void Drive() {cout << "virtual void Drive() " << endl;}
};
class Benz :public Car 
{
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{Benz b;b.Drive();return 0;
}

在这里插入图片描述

重载、覆盖(重写)、隐藏(重定义)的对比

在这里插入图片描述

抽象类

多态的原理

虚函数表

过程
         编译器在编译时，为每个有虚函数的类生成一个独立的虚函数表，这是一个静态数组，存的是函数指针。
         基类有自己的 vtable。
         派生类也有自己的 vtable。

派生类的 vtable 构建方式：

先把基类的虚函数列表内容 “继承” 过来（不是运行时拷贝，而是编译时直接生成新的表）。
如果派生类重写了某个虚函数，就在自己的 vtable 中替换掉对应位置的函数指针，指向新的实现。
如果派生类新增了虚函数，就会把这些新函数的指针追加到 vtable 末尾。

对象里只有一个 vptr（虚表指针），指向所属类的 vtable。

构造对象时，编译器自动插入代码，让 vptr 指向该类的 vtable。

虚函数放在代码段里，虚函数表里存放着虚函数的地址。

#include<iostream>
using namespace std;
class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}virtual void Func2(){cout << "Func1()" << endl;}     void Func3(){cout << "Func1()" << endl;}
private:char _b = 1;
};
int main()
{cout << sizeof(Base) << endl;Base b;return 0;
}

在这里插入图片描述

结论

派生类对象 d 中也有一个虚表指针，d 对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
基类 b 对象和派生类 d 对象虚表是不一样的，这里我们发现 Func1 完成了重写，所以 d 的虚表中存的是重写的 Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
另外 Func2 继承下来后是虚函数，所以放进了虚表，Func3 也继承下来了，但是不是虚函数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个 nullptr。

在这里插入图片描述

派生类的虚表生成：
（1）先将基类中的虚表内容拷贝一份到派生类虚表中（2）如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
（3）派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
虚表存储在代码段，虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。同类型的对象共用虚表。

代码验证虚表存在代码段

#include<iostream>
using namespace std;
class Person 
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}virtual void Func1(){}virtual void Func2(){}
protected:int _a = 0;
};
class Student : public Person 
{
public:virtual void BuyTicket(){cout << "买票-半价" << endl;}
protected:int _b = 1;
};
int main()
{int a = 0;printf("栈:%p\n", &a);static int b = 0;printf("静态区:%p\n", &b);int* c = new int;printf("堆区:%p\n", &c);const char* d = "hello world";printf("常量区(代码段):%p\n", d);Person ps1;Student st1;printf("虚表1:%p\n", *((int*)&ps1));printf("虚表2:%p\n", *((int*)&st1));return 0;
}

在这里插入图片描述
找到隐藏的 Func3 函数

#include<iostream>
using namespace std;
class Person 
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}virtual void Func1(){cout << "Person:Func1()" << endl;}virtual void Func2(){cout << "Person:Func2()" << endl;}
//protected:int _a = 0;
};
class Student : public Person 
{
public:virtual void BuyTicket(){cout << "买票-半价" << endl;}virtual void func3(){cout << "Student:Func3()" << endl;}
protected:int _b = 1;
};
void Func(Person& p)
{p.BuyTicket();
}
//打印函数指针数组
typedef void(*FUNC_PIR) ();
//void PrintVFT(FUNC_PIR table[])
void PrintVFT(FUNC_PIR* table)
{for (size_t i = 0; table[i] != nullptr; i++){printf("[%d]:%p->", i, table[i]);FUNC_PIR f = table[i];f();}printf("\n");
}
int main()
{Person ps;Student st;int vft1 = *((int*)&ps);//取出4个字节PrintVFT((FUNC_PIR*)vft1);int vft2 = *((int*)&st);PrintVFT((FUNC_PIR*)vft2);return 0;
}

在这里插入图片描述
监视窗口没有显示 Func3，经过内存查找得到了 Func3 的地址。

动态绑定与静态绑定

静态绑定又称为前期绑定 (早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

多继承中的虚函数表

#include<iostream>
using namespace std;
class Base1 
{
public:virtual void func1() { cout << "Base1::func1" << endl; }virtual void func2() { cout << "Base1::func2" << endl; }
private:int b1;
};
class Base2 
{
public:virtual void func1() { cout << "Base2::func1" << endl; }virtual void func2() { cout << "Base2::func2" << endl; }
private:int b2;
};
class Derive : public Base1, public Base2 
{
public:virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func3" << endl; }
private: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;Base1 b1;Base2 b2;cout << "sizeof(d):" << sizeof(d) << endl;int vft1 = *((int*)&d);PrintVTable((VFPTR*)vft1);//方法1//int vft2 = *((int*)((char*)&d + sizeof(Base1)));//方法2Base2* ptr = &d;int vft2 = *((int*)ptr);PrintVTable((VFPTR*)vft2);return 0;
}

在这里插入图片描述

寄存器 ecx 存储的是 this 指针的地址。Derive 和 Base1 的地址的开始重叠。ptr1 的 this 指针指向的是 Derive 对象的开始。ptr2 的 this 指针指向的是 Base2 的开始，距离 Base1 的开始有 8 个字节。
在这里插入图片描述

在这里插入图片描述

总结

多态的核心是 “运行时确定函数调用”，依赖虚表（vtable）与虚表指针（vptr）：子类继承基类虚表后，重写函数覆盖表项，通过 vptr 实现动态绑定。需牢记析构函数设虚函数、用 override/final 规范重写等细节。建议结合案例改代码、自定义类验证虚表，通过实践掌握多态，写出高可维护的 C++ 代码。

查看全文

http://www.dtcms.com/a/516217.html