开发者

C++中的多态问题—理解虚函数表及多态实现原理

目录
  • 一、多态的概念
    • 概念
    • 构成条件
  • 二、虚函数的重写
    • 重写的定义
    • 重写的特殊情况
    • override和final关键字
    • 区分重写、重载、重定义
    • 抽象类的概念
  • 三、多态的实现原理
    • 父类对象模型
    • 补充:生成默认构造方法的场景
    • 子类对象模型
    • 多态的调用原理
    • 多继承的虚函数表
  • 四、继承与多态中的常见问题
    • 总结

      注:编译环境为VS 2022,指针大小为4字节

      一、多态的概念

      概念

      多态,指完成某个行为,不同的对象去完成时会产生出不同的状态。如:定一个一Animal类,类中包含动物的叫声这种方法,分别定义Dog和Cat类继承自动物类,那么Dog和Cat类中也会包含叫声这种方法,但是他们具体实现是不同的,因为每种动物的声音都不相同,这便是一种多态。

      多态的分类

      • 静态多态,也称为静态绑定或者早绑定,是指函数在编译期间就已经确定了函数的行为。函数重载、函数模板等都属于静态多态。
      • 动态多态,即动态绑定或者晚绑定,指程序在运行时才可以确定函数的行为。本文主要分析的是动态多态。

      构成条件

      • 在继承体系下,父类中包含虚函数
      • 子类中对父类的虚函数进行重写
      • 通过父类的指针或者引用调用虚函数

      多态的体现:不同的类对象调用同一函数,会产生不同的行为。

      二、虚函数的重写

      重写的定义

      虚函数:virtual关键字修饰的函数

      子类中有一个跟父类完全相同的虚函数,即返回值类型函数名形参列表都完全相同,则可以说子类重写了父类的虚函数。

      Student类中重写了BuyTicket方法:

      C++中的多态问题—理解虚函数表及多态实现原理

      注意:只http://www.devze.com要父类中函数用virtual修饰即可,子类可以不加,且虚函数的重写与权限无关。

      重写的特殊情况

      协变——返回值类型不同

      父类的虚函数返回父类对象的指针或者引用,子类虚函数返回子类对象的指针或者引用。

      C++中的多态问题—理解虚函数表及多态实现原理

      析构函数重写——父类与子类析构函数名字不同

      如果父类的析构函数为虚函数,子类的析构函数只要定义了,都能与父类的析构函数构成重写。可以理解为编译器对析构函数的名字做了特殊处理,编译后析构函数的名字统一处理成destructor。

      C++中的多态问题—理解虚函数表及多态实现原理

      override和final关键字

      这两个关键字的主要作用都是帮助用户检测是否构成重写

      • final:修饰虚函数,表示虚函数不可被重写;另外final也可以修饰类,表示该类不能被继承

      C++中的多态问题—理解虚函数表及多态实现原理

      • override:修饰虚函数,检查子类虚函数是否重写了父类的虚函数,如果没有构成重写则会报错

      C++中的多态问题—理解虚函数表及多态实现原理

      区分重写、重载、重定义

      C++中的多态问题—理解虚函数表及多态实现原理

      抽象类的概念

      在虚函数的后面写上=0,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也称接口类),抽象类不能实例化对象。抽象类被集成以后如果没有对虚函数进行重写,则继承的类也是抽象类。

      一般情况下,抽象类必须被继承,且必须对虚函数进行重写,否则定义为抽象类则没有实际意义。

      Shape类:

      class Shape
      {
      public:
      	// 纯虚函数
      	virtual double GetArea() = 0;
      	virtual double GetCircumference() = 0;
      };
      

      C++中的多态问题—理解虚函数表及多态实现原理

      三、多态的实现原理

      父类对象模型

      给出一个Base类,一个Derived类继承Base类

      class Base
      {
      public:
      	virtual void Func1()
      	{
      		cout << "Base::Fun1c()" << endl;
      	}
      	virtual void Func2()
      	{
      		cout << "Base::Func2()" << endl;
      	}
      	virtual void Func3()
      	{
      		cout << "Base::Func3()" << endl;
      	}
      public:
      	int  _a;
      };
      
      class Derived:public Base
      {
      public:
      	int _b;
      };
      

      父类对象模型:

      C++中的多态问题—理解虚函数表及多态实现原理

      总结:

      • 类中定义了虚函数以后,定义对象时,编译器会为对象创建一张虚表,并将一个指向这张虚表的指针保存在对象的前四个字节,无论定义几个虚函数,对象都只比多四个字节大小。这个指针称为函数虚表指针。
      • 虚表地址是在构造对象时进行填充的,构造函数如果显式实现,编译器会对用户实现的函数进行修改,增加给对象前四个字节存放虚表地址的语句。
      • 虚表本质就是一个函数指针数组,按照声明顺序依次存放虚函数的地址

      补充:生成默认构造方法的场景

      在学习类与对象时我们知道构造函数是是类的默认成员函数,如果用户没有显式定义,编译器会默认生成,但是实际上并不是在所有情况下编译器都会生成默认的构造函数,编译器只会在需要的时候生成构造函数。

      四种生成默认构造方法的场景

      B类中包含有A类的对象,B类没有显式定义构造函数,A类定义了无参或者全缺省的构造方法,则编译器会给B类生成默认的构造方法。

      分析:因为A类有无参或者全缺省的构造方法,需要在B类中调用A类的构造方法对A类成员进行初始化,所以需要生成B类的构造方法,在其初始化列表中调用A类构造方法。

      如果A类没有显式定义构造函数,则不会生成B类构造方法,默认赋随机值;如果A类定义的构造方法不是无参或者全缺省的,则需要在android初始化列表中对A类对象初始化: 

      C++中的多态问题—理解虚函数表及多态实现原理

      继承中,B继承A,A中定义了无参或者全缺省的构造方法,B未显式定义,则编译器会给B类生成默认的构造方法。将B中继承自A的部分初始化。

      虚拟继承中,B类虚拟继承子A类,B类未显式定义构造方法,编译器会给B类生成默认www.devze.com的构造方法,目的是:给B类对象的前4个字节填充虚基表地址

      类中包含虚函数,未显示定义构造方法,则编译器会自动生成构造方法,为对象的前4个字节填充虚表地址

      子类对象模型

      子类虚表构建规则

      1.将父类虚表内容拷贝一份放到子类虚表中,注意父类和子类用的不是同一张虚表,仍以上面的Base和Derived类为例js

      C++中的多态问题—理解虚函数表及多态实现原理

      可以看出,两个虚表指针的地址不同,但虚表中保存的虚函数的地址都相同

      2.如果子类中将父类的虚函数进行了重写,则用子类的虚函数地址替换虚函数表中相同偏移量的虚函数的地址。

      C++中的多态问题—理解虚函数表及多态实现原理

      3.子类中增加的虚函数按照其在类当中的声明次序放在虚表的最后

      子类中增加了两个虚函数:

      C++中的多态问题—理解虚函数表及多态实现原理

      但是由于VS监视窗口中无法显式新增加的子类,而内存窗口只能显式虚函数的地址,无法确认是哪个函数,所以这里通过打印的方式进行验证。

      C++中的多态问题—理解虚函数表及多态实现原理

      通过上图中程序的方式打印出了子类对象中虚函数的分布情况,在这里VFP是一个函数指针类型,前面加typedef表示为函数指针类型,如果不加,则是函数指针变量。

      所以是用VFP*接收指向第一个虚函数指针的指针,p与*p的类型:

      C++中的多态问题—理解虚函数表及多态实现原理

      所以最终的结论是:子类新增的虚函数按照其在类中的声明次序放在虚函数表的最后。

      子类对象的构造过程

      构造子类对象时,在初始化列表中先调用父类的构造函数,此时对象的前4个字节保存的虚表指针指向父类的虚表,之后构造子类自己的虚表,虚表再指针指向子类的虚表。

      总结

      • 虚表的本质是函数指针数组,在编译时生成
      • 虚函数的重写也叫覆盖,指的是虚表中虚函数的覆盖,重写是语法层的叫法,覆盖是原理层的叫法
      • 对象中保存的是虚表指针,虚表中保存的是虚函数指针,虚函数和普通函数一样保存在代码段http://www.devze.com,在VS中虚表也保存在代码区
      • 同一个类的对象共用同一张虚表,父类和子类各自拥有各自的虚表。

      多态的调用原理

      父类对象,函数调用时的汇编代码:

      C++中的多态问题—理解虚函数表及多态实现原理

      普通函数调用时直接传递函数的地址,这个地址在编译期间就确定了,虚函数则要经过虚表指针寻址等步骤。从上面的汇编代码也可以看出动态多态的晚绑定的特点,在编译期间普通函数的调用已经确定了要调用的具体函数,虚函数则无法确定,只有等程序运行起来,形参b是具体哪个对象确定了以后,才能确定要调用的函数的地址

      上面是传递父类对象时的调用情况,子类对象调用时的汇编代码与父类对象相同,区别就是子类对象有自己的虚表,最终调用的是子类需表中的函数。

      总结多态的原理:

      创建对象时,编译器会给包含虚函数的类对象创建一张虚表,并将虚表地址填充在对象的前4个字节,子类对象会拷贝父类对象的虚表,然后再对自己重写的虚函数进行替换,并在虚表中添加子类新增的虚函数;函数调用时,编译器会先从对象的前4个字节获取该对象虚表的地址,然后在虚表中获取虚函开发者_开发入门数地址进行函数调用;由于每个类对象都有属于该类的一张虚表,且虚函数一般都进行了重写,即函数名与父类相同,但函数执行的内容不同,最终产生的结果就是,不同类的对象调用同一函数产生不同的结果,由此形成了多态。

      多继承的虚函数表

      给出两个父类Base1和Base2,Derived子类继承自两个父类

      C++中的多态问题—理解虚函数表及多态实现原理

      通多监视窗口查看子类对象的模型:

      C++中的多态问题—理解虚函数表及多态实现原理

      多态中多继承的子类对象模型与多继承的模型原理相同,但是VS的监视窗口无法查看子类新增的虚函数在需表中的位置,按照之前但继承中打印虚表中函数的原理进行打印:

      C++中的多态问题—理解虚函数表及多态实现原理

      最终得到的结果:

      C++中的多态问题—理解虚函数表及多态实现原理

      可以看出,子类中增加的虚函数保存在上面的虚表中。

      多继承子类对象模型及对象虚表:

      C++中的多态问题—理解虚函数表及多态实现原理

      四、继承与多态中的常见问题

      1.析构函数可以设置为虚函数吗?

      可以,在继承体系中,最好将父类的析构函数设置为虚函数;如果子类中涉及到资源管理,则必须将父类的析构函数设置为虚函数,这样父类和子类中的析构函数便会构成重写(重写的特殊情况),形成多态,通过父类指针指向子类对象时,delete父类对象的指针也会调用子类的析构函数

      子类中涉及资源管理,调用父类析构函数析构子类对象,则会有内存泄漏,如图:

      C++中的多态问题—理解虚函数表及多态实现原理

      C++中的多态问题—理解虚函数表及多态实现原理

      2.构造函数可以设置为虚函数吗?

      不能,虚函数是放在虚表中的,虚表指针是在构造方法的初始化列表中进行填充的,通过虚表指针才能找到虚函数,但是不调用构造方法就没有虚表指针,二者矛盾。即如果构造方法是虚函数,那么调用构造方法就要通过虚表指针,但是虚表指针是要通过调用构造方法才能填充的。拷贝构造与构造函数原理相同。

      C++中的多态问题—理解虚函数表及多态实现原理

      3.赋值运算符重载函数可以设置为虚函数吗?

      可以,但是没有意义,因为赋值运算符重载函数参数和返回值都是本类类型对象的引用,设置程序函数无法进行重写,无法构成多态。

      4.静态函数可以设置为虚函数吗 ?

      虚函数必须在创建对象后,通过对象的前4个字节的虚表指针调用。而静态成员函数可以通过 类名::成员函数 的方式进行调用,不用通过象,这样就无法找到虚表,也无法访问虚函数。

      C++中的多态问题—理解虚函数表及多态实现原理

      5.内联函数可以是虚函数吗?

      可以设置,但是没有意义,因为虚函数关键字virtual和inline是矛盾的,inline属性会被忽略,函数不会展开,而是放到虚函数表中。

      6.友元函数可以是虚函数吗?

      不可以,因为virtual只能修饰类的成员函数。

      C++中的多态问题—理解虚函数表及多态实现原理

      7.为什么多态必须通过指针或者引用实现?

      因为当我们用一个父类指针或者引用指向子类对象时,会发生内存切割,用子类中属于父类的部分给父类赋值:

      	Animal& animal1 = dog;
       	Animal* animal2 = new Dog();
      

      而下面的语句则不会产生内存切割:

      Ainmal animal3 = dog;

      为什么会这样呢?

      “一个pointer或一个reference之所以支持多态,是因为它们并不引发内存任何“与类型有关的内存委托操作; 会受到改变的。只有它们所指向内存的大小和解释方式 而已”。 ——《深度探索C++对象模型》

      总结

      以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

      0

      上一篇:

      下一篇:

      精彩评论

      暂无评论...
      验证码 换一张
      取 消

      最新开发

      开发排行榜