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

【C++】多态(虚函数/虚函数表/菱形）

news 2026/7/23 19:41:02

目录

1. 多态的概念

2. 多态的定义及实现

2.1多态的构成条件

2.2 虚函数

2.3虚函数的重写

2.4 C++11 override 和 final

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

3.抽象类

4.多态的原理

4.1虚函数表

4.2多态的原理

4.3 动态绑定与静态绑定

5.单继承和多继承关系的虚函数表

5.1 单继承中的虚函数表

5.2 多继承中的虚函数表

6.菱形虚拟继承 + 多态的场景

1. 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态

  • 静态多态：函数重载
  • 多态多态：继承体系中虚函数重写 + 父类指针的调用

2. 多态的定义及实现

2.1多态的构成条件

多态是在同一继承体系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：

1.必须通过基类的指针或者引用调用虚函数

如果满足多态，基类的指针或者引用会调用指向的对象的虚函数，如果不满足，基类的指针或者引用只会调用该指针的类型或引用的类型的虚函数

// 假设 person 和 student 的 buyticket 函数满足多态 person* p; p = new person; p.buyticket(); // 调用 person 的 buyticket p = new student; p.buyticket(); // 调用 student 的 buyticket // 如果 buyticket 函数不满足多态，只是构成隐藏关系 person* p; // 只会根据 p 的类型去调用相应的函数， p = new person; p.buyticket(); // 调用 person 的 buyticket p = new student; p.buyticket(); // 还是会调用 person 的 buyticket

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

2.2 虚函数

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

  1. 只有类的成员函数才能成为虚函数，全局函数不行，
  2. 虚函数在语法上可以是内联函数，但不能成为真正的内联函数，起码编译器会忽略 inline，在底层上因为内联函数要在编译期在调用时展开，而虚函数要在运行时才能确定调用哪个虚函数。
  3. 虚函数在语法上就不能是静态函数，因为静态函数没有 this 指针，无法确定调用对象。
  4. 虚函数不能是构造函数，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的，而要调用构造函数又必须通过虚函数表指针寻找。
class Person { public: virtual void BuyTicket() { cout << "买票-全价" << endl;} };

2.3 虚函数的重写

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

class Person { public: virtual void BuyTicket() { cout << "买票-全价" << endl; } }; class Student : public Person { public: virtual void BuyTicket() { cout << "买票-半价" << endl; } /*注意：在重写基类虚函数时，基类的虚函数添加了 virtual 关键字， 而派生类的虚函数不加 virtual 关键字，虽然也可以构成重写(因为继承后基类的 虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用*/ /*void BuyTicket() { cout << "买票-半价" << endl; }*/ };

虚函数重写的两个例外：

1.协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型可以不同，但返回值只能同时是基类或子类的指针或引用（或同时是其他继承体系的基类或子类的指针或引用），若是其他类型会报错。且基类函数返回值类型必须是基类的指针或引用，子类虚函数返回值类型必须是子类的指针或引用。

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;} };

2.析构函数的重写(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要一定义，就与基类的析构函数构成重定义（注意不是重写），虽然基类与派生类析构函数名字不同，看起来违背了重定义的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor。父类析构函数不加 virtual 的情况下，子类析构函数和父类析构函数构成隐藏关系。

class Person { public: virtual ~Person() {cout << "~Person()" << endl;} }; class Student : public Person { public: virtual ~Student() { cout << "~Student()" << endl; } }; // 只有派生类 Student 的析构函数重写（不是重定义）了 Person的析构函数， // 下面的delete对象调用析构函数 // 才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。 int main() { Person* p1 = new Person; Person* p2 = new Student; // 构成多态的情况下 delete p1; // 调用 ~Person() delete p2; // 调用 ~Student() // 如果没有构成多态，都是调用的 ~Person()，student 可能不能正确析构 return 0; }

基类和派生类的析构函数必须构成重写，因为某些场景：

// 如果 person 和 student 的析构函数没有构成多态，只是隐藏关系 Person* p = new Person; delete p; // 此时没有问题，调用 person 的析构函数 p = new Student; delete p; // error // 由于 person 和 student 的析构函数没有构成多态 // 析构函数的名称被编译器统一为 destructor // delete p ： // p->destructor()(这个destructor是person的destructor！） + operator delete(p) // 这里我们期望p->destructor()是一个多态调用,而不是普通调用 // 所以基类和子类的析构函数必须构成重写

以下程序输出结果是什么（）

class A { public: virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;} virtual void test(){ 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; }

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

答案： B: B->1 解释：p 是 B 类的指针，用 p 调用 test 函数，由于 B 类继承了 A 类，而 B 类没有重写 A 类的 test 函数，所以 p 调用 test 函数，实际调用的是 A::test()，在 A 类中，test 函数被编译器处理为：

void test(A* this){this->func();}

p 调用 test 函数时，将 p 传递给 this （派生类的指针可以赋值给基类的指针），所以 this 实际指向的是一个 B 类的对象， 而 B 类重写了 func 函数，现在又是用基类的指针（this 是 A* 类型的）去调用 func 函数，满足了多态的条件，所以实际调用的是 B 类的 func 函数，但默认参数val的值为1（由A::func的声明决定，编译期绑定）。只要记住：虚函数重写，重写的是实现

2.4 C++11 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数
名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有
得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

1. final：修饰虚函数，表示该虚函数不能再被重写

class Car { public: virtual void Drive() final {} }; class Benz :public Car { public: virtual void Drive() {cout << "Benz-舒适" << endl;}// 报错 };

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car{ public: virtual void Drive(){} }; class Benz :public Car { public: virtual void Drive() override {cout << "Benz-舒适" << endl;} // 检查 Drive() 是否重写了基类的某个虚函数，没有会报错 };

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

3.抽象类

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

class Car { public: virtual void Drive() = 0; }; class Benz :public Car { public: virtual void Drive() { cout << "Benz-舒适" << endl; } }; class BMW :public Car { public: virtual void Drive() { cout << "BMW-操控" << endl; } };

4.多态的原理

4.1虚函数表

// sizeof(Base)是多少？ class Base { public: virtual void Func1() { cout << "Func1()" << endl; } private: int _b = 1; };

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

那么派生类中这个表放了些什么呢？我们接着往下分析

// 针对上面的代码我们做出以下改造 // 1.我们增加一个派生类Derive去继承Base // 2.Derive中重写Func1 // 3.Base再增加一个虚函数Func2和一个普通函数Func3 class Base { public: virtual void Func1() { cout << "Base::Func1()" << endl; } virtual void Func2() { cout << "Base::Func2()" << endl; } void Func3() { cout << "Base::Func3()" << endl; } private: int _b = 1; }; class Derive : public Base { public: virtual void Func1() { cout << "Derive::Func1()" << endl; } private: int _d = 2; }; int main() { Base b; Derive d; return 0; }

通过观察和测试，我们发现了以下几点问题：

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员（包括父类的数据成员和虚表指针，拷贝父类的虚表指针指向的内容给子类），另一部分是自己的成员。
  2. 基类b对象和派生类d对象虚表是不一样的，因为派生类d中对Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了nullptr。
  5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
  6. 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的。
  7. __vfptr 是 void** 类型的指针，因为虚表中存储的都是类型为 void* 的指针，为什么呢？因为一个类的所有虚函数的返回值和形参很可能不同，而指针数组又只能存储同一种类型的指针，而 void* 类型的指针可以指向任何类型，所以虚表里的函数指针被设计为 void* 类型。

虚表存在哪里呢？

首先排除堆，其次排除栈，因为同一个类的对象共用一个虚表，调用某个函数建立栈帧时，同一个类的对象的虚表一样。验证虚表在哪里的代码如下所示，因为在同一个内存分区的变量的地址一般相差较小，代码运行的结果表示虚表可能在常量区。注意取出虚表地址的操作：*((int*)&ps)) （在32 位操作系统下，指针的大小是 4 字节，取出 ps 的地址后强制转换为 int* 型，就得到前 4 个字节，也就是那个虚表指针的值，也就是虚表的首地址）

4.2多态的原理

多态的原理到底是什么？还记得这里Func函数传Person调用的Person::BuyTicket，传Student调用的是Student::BuyTicket吗？

class Person { public: virtual void BuyTicket() { cout << "买票-全价" << endl; } }; class Student : public Person { public: virtual void BuyTicket() { cout << "买票-半价" << endl; } }; void Func(Person& p) { p.BuyTicket(); } int main() { Person Mike; Func(Mike); Student Johnson; Func(Johnson); return 0; }

1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中
找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中去找的。不满足多态的函数调用是编译时确认好的。

void Func(Person* p) { p->BuyTicket(); } int main() { Person mike; Func(&mike); mike.BuyTicket(); return 0; } // 以下汇编代码中跟你这个问题不相关的都被去掉了 void Func(Person* p) { ... p->BuyTicket(); // p中存的是mike对象的指针，将p移动到eax中 001940DE mov eax,dword ptr [p] // [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx 001940E1 mov edx,dword ptr [eax] // [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax 00B823EE mov eax,dword ptr [edx] // call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来 以后到对象的中取找的。 001940EA call eax 00头1940EC cmp esi,esp } int main() { ... // 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调 用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址 mike.BuyTicket(); 00195182 lea ecx,[mike] 00195185 call Person::BuyTicket (01914F6h) ... }

4.3 动态绑定与静态绑定

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

5.单继承和多继承关系的虚函数表

需要注意的是在单继承和多继承关系中，下面我们去关注的是派生类对象的虚表模型，因为基类
的虚表模型前面我们已经看过了，没什么需要特别研究的

5.1 单继承中的虚函数表

class Base { public : virtual void func1() { cout<<"Base::func1" <<endl;} virtual void func2() {cout<<"Base::func2" <<endl;} private : int a; }; class Derive :public Base { public : virtual void func1() {cout<<"Derive::func1" <<endl;} virtual void func3() {cout<<"Derive::func3" <<endl;} virtual void func4() {cout<<"Derive::func4" <<endl;} private : int b; };

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这
两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印
出虚表中的函数。

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() { Base b; Derive d; // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数 指针的指针数组，这个数组最后面放了一个nullptr // 1.先取b的地址，强转成一个int*的指针 // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针 // 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。 // 4.虚表指针传递给PrintVTable进行打印虚表 // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最 后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再 编译就好了。 VFPTR* vTableb = (VFPTR*)(*(int*)&b); PrintVTable(vTableb); VFPTR* vTabled = (VFPTR*)(*(int*)&d); PrintVTable(vTabled); return 0; }

5.2 多继承中的虚函数表

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; VFPTR* vTableb1 = (VFPTR*)(*(int*)&d); PrintVTable(vTableb1); VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1))); // 或 base2* ptr = &d; VFPTR* vTableb2 = (VFPTR*)((int*)ptr); PrintVTable(vTableb2); return 0; }

观察下图可以看出：多继承派生类的新增的虚函数放在第一个继承基类部分的虚函数表中

6.菱形虚拟继承 + 多态的场景

场景示例

class A { public: virtual void foo() {} int a; }; class B : virtual public A { public: virtual void bar() {} int b; }; class C : virtual public A { public: virtual void baz() {} int c; }; class D : public B, public C { public: virtual void qux() {} int d; };

对象的内存布局

如果B和C都尝试重写A的虚函数foo()，会导致二义性问题，因为D继承B和C后A::foo()被B和C同时重写，导致D不知道选择哪个版本。解决方案是D自己重写foo()

http://www.jsqmd.com/news/1249674/

相关文章：

  • 树莓派4B变身软路由全攻略：从OpenWrt刷机到双网卡配置避坑指南
  • 2026 海南海口 OPC 公司注册收费标准，封关后地址、代办、税务全成本明细 - 米諾
  • 本地隐私 AI 工具 OpenClaw ，Windows/Mac 新手全流程安装 + 故障排查汇总
  • 脑筋急转弯API调用边界与QPS限制解析：20并发下的稳定性实践
  • 大连名表回收哪家价高？本地商家实测对比 - 大牌深度测评
  • Banana Pi BPi-R3 Mini 刷机指南：ImmortalWrt 固件从下载到安装全流程
  • YOLO26的SPASPP模块：提升红外小目标检测精度
  • 无痕粘接赛道存活指南：活得好的品牌都做对了什么 - 米諾
  • WebAssembly AI 数据隐私：用户数据不出浏览器，推理在本地完成的架构
  • 斐讯N1盒子刷软路由OpenWrt
  • 深入解析以太网MAC DMA操作模式寄存器：嵌入式网络性能调优核心
  • 金融问答机器人中的知识蒸馏技术实践
  • 4 位还是 8 位：ASC4T245S 与 ASC8T245S 的选型图谱
  • 易拉罐正反面识别数据集下载，支持yolo，coco json，pasical voc xml格式的标注信息，平均正确识别率为99.5%，训练集2373张图片
  • MySQL锁
  • 公众号账号转移有哪些用处？线上申办实操指南 - 跑政通
  • 2026 昆明奢侈品回收最靠谱平台，易奢福 30 年连锁龙头全城可上门 - 肉松卷
  • 企业级数据中台建设方法论：从消除孤岛到资产复用的完整落地路径
  • OpenWRT软路由上Docker部署青龙面板+Ninja的避坑指南（附常见错误解决方案）
  • 媒体发稿：品牌长青的隐形引擎
  • openwrt软路由配置3
  • 2026武汉奢侈品回收新规落地：旧套路彻底失效！普通人变现避坑新逻辑 - 二奢分享官
  • c++-引用（包括完美转发，移动构造，万能引用）
  • 【计算机Python毕业设计案例】基于 Python 的大学生二手好物分享与互动交易系统 校园二手交易互动评论咨询平台设计(程序+文档+讲解+定制)
  • 食品罐头表面缺陷识别数据集：支持YOLO、COCO、Pascal VOC格式，2278张标注图像，识别率98.7%
  • 从“带货”到“带认知”——海外网红营销如何让便携风扇品牌在每个夏天都有“先发优势”
  • 基于springboot+智能ai+推荐算法的惠农帮扶平台
  • 2026年北京国贸区域专业婚姻律师事务所体验评测 - 起跑123
  • 深入解析TI F021 Flash控制器：寄存器配置与诊断模式实战指南
  • Windows安装Ubuntu20.04系统(双系统）