C++多态详解——多态的原理，单继承和多继承的虚函数表

Dear 丶 2023-01-22 04:54 42阅读 0赞

# 一、多态的原理 #

## 1.1 虚函数表和虚函数表指针 ##

举个栗子来认识虚函数表，这是一道常考的笔试题，32位操作系统下sizeof(Base)是多少？

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

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

**总结：**

> **虚函数表指针**又称虚表指针，其本质是一个指向函数指针数组的指针，  
> **虚函数表**又称虚表，其本质是一个函数指针数组，这个数组中存放了虚函数的地址。

如果还不清楚通过下面这幅图来区分这两个概念  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]

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

// 针对上面的代码我们做出以下改造
    // 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.  **基类对象b和派生类对象d中各有一个虚表指针**，d对象由两部分构成，一部分是父类继承下来的成员，另一部分是自己的成员。
2.  **基类b对象和派生类d对象虚表是不一样的**，这里我们发现Func1完成了重写，所以**d的虚表中存的是重写的Derive::Func1**，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3.  另外Func2继承下来后是虚函数，所以放进了虚表，**Func3**也继承下来了，但是**不是虚函数**，所以**不放进虚表**。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]
4.  虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]  
**总结**

1.  派生类的虚表生成：

*  先将基类中的虚表内容**拷贝**一份到派生类虚表中
 *  如果派生类**重写**了基类中某个虚函数，用**派生类自己的虚函数覆盖虚表中基类的虚函数**
 *  派生类自己新增加的虚函数按其在派生类中的**声明次序**增加到派生类虚表的最后。
 *  **注意这里的派生类继承的虚函数存放顺序是按基类的声明次序存放的**，不要和上面的搞混淆  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]

### Q1：虚函数存在哪的？虚表存在哪的？虚表指针存在哪的？ ###

从上面的代码中我们可以看到虚表指针\_vtptr在对象的前四个字节，那么我们打印地址来看一下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]

总结：

*  **虚函数和普通函数一样存在代码段，虚函数的指针存在了虚函数表中**
 *  **虚函数表也存在代码段**
 *  **对象中存的不是虚函数表，而是虚函数表指针**

## 1.2 多态原理 ##

掌握了上面两个概念后我们就可以很好的理解多态的原理了  
对于一个普通对象，你是什么类型就调用什么类型，即使发生切片，也不会覆盖掉基类原有的虚表  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]  
如果传入的是基类的指针或引用，**虽然指针类型是基类，但是指向的对象却是派生类**，那么就可以看到派生类对象的虚表，就可以在派生类对象的虚表中找到覆盖的虚函数，从而达到同一对象不同功能的效果

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]  
**上面看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象中去找的。不满足多态的函数调用编译时就确认好的**  
总结：  
满足多态的两个条件：

*  虚函数覆盖-目的是不同类型具有不同类型的功能
 *  基类对象的指针或引用调用虚函数-目的是找到虚函数表调用覆盖的虚函数

## 1.3 动态绑定和静态绑定 ##

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

# 二、单继承和多继承关系的虚函数表 #

基类的虚表模型前面我们已经看过了，没什么需要特别研究的，下面来看一下不同继承的虚表

## 2.1 单继承中的虚函数表 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]  
从上面可以看到func1覆盖，func2保留，而3和4隐藏了，那么如何查看呢？  
首先我们知道对象中保存的是**虚函数表指针**，这个指针指向的是一个**虚函数表**，虚函数表中存放的是**虚函数地址**，那么我们就一层一层分解这个过程就可以了

*  先取b的地址`&b`，强转成一个int\*的指针`(int*)&b`，再解引用取值`*((int*)&b)`，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
 *  虚表实质是一个函数指针数组，我们写一个函数指针数组的类型出来，先写一个指针数组`void (*VFPTR)[]`,再写一个函数指针`void(*VFPTR)()`,这个函数指针难理解我们将函数指针typedef成VFPTR  
    `typedef void(*VFPTR)();`
 *  函数指针是VFPTR\*，最后写一个函数指针数组出来`VFPTR*(p)[]`,这样虚表的类型就写出来了，剩下的就是写一个函数将虚表的地址传递过来
 *  虚表是一个存函数指针的数组，因此我们将虚表强制转换成VFPTR\*，然后将虚表指针传递给函数  
    `void PrintVTable(VFPTR vTable[])`
 *  函数体内依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数  
    具体代码：

//5.单继承
    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;
    };
    
    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的地址&b，强转成一个int*的指针(int*)&b，再解引用取值*((int*)&b)，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    	printf("b对象虚表指针：%p\n", (*(int*)&b));
    	printf("d对象虚表指针：%p\n",(*(int*)&d));
    	// 2.虚表实质是一个函数指针数组
    	// 3.先写一个指针数组void (*VFPTR)[],再写一个函数指针void(*VFPTR)(),这个函数指针难理解我们typedef以下
    	typedef void(*VFPTR)();
    	// 4.函数指针是VFPTR*，最后写一个函数指针数组出来VFPTR*(p)[]
    	// 5.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组
    	// 6.虚表指针传递给PrintVTable进行打印虚表.
    	cout << "我是Base" << endl;
    	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    	PrintVTable(vTableb);
    	cout << "我是Derive" << endl;
    	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTabled);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]

可以看到只是编译器做了隐藏，实际fun3和func4是存在虚表中的，单继承较好理解，下面分析多继承

## 2.2 多继承的虚函数表 ##

我们写一个多继承

//6.多继承
    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 _d;
    };
    
    int main()
    {
        
    	Base1 b1;
    	Base2 b2;
    	Derive d;
    	return 0;
    }

Base1有虚函数func1,func2  
Base2有虚函数func1,func2  
Derive继承Base1,Base2,重写func1，自定义虚函数func3

多继承带来了三个问题  
**1. 对象d的大小是多少？  
2. 自定义的虚函数func3只存在Base类其中一个虚表中还是都存？  
3. 重写func1后的地址在Base1和Base2的虚表中地址不相同？**

我们一个一个剖析问题

### 问题1：对象d的大小是多少？![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 10] ###

如上图所示Base1和Base2中分别含有一个虚表指针和一个int类型变量共16字节，Derive继承下来后还有自己一个int变量4字节，一共20字节

### 问题2：自定义的虚函数func3只存在Base类其中一个虚表中还是都存？ ###

### 问题3：重写func1后的地址在Base1和Base2的虚表中地址不相同？ ###

这两个问题一起解决  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 11]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]: /images/20221020/d888e8ce82ab48db8170fbb807a4ea9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]: /images/20221020/f3a6e2c0c17842cca8eae4af6a2b8b36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]: /images/20221020/26af2fa607d94607abd1230d4e2004ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]: /images/20221020/2f9accde775a420cae4916071362d2ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]: /images/20221020/e9bb95d5c4224e6ea05623aa761afaa5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]: /images/20221020/456b7577690946fdbc75651cad1c5f75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]: /images/20221020/2d01f8fe6a5e4a21aa6182ba87c9512c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]: /images/20221020/2e22917891bd40a5b04515758a045819.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]: /images/20221020/66029cc74e214702af1d4e60019875f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]: /images/20221020/d83a4187850c437e815e14f95d3d9da1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 10]: /images/20221020/eb3fd2cdf55640fb97c5ad613f968d74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 11]: /images/20221020/0e2485a403124c2bb45eef4621191cc2.png