【C++】多态 —— 条件 | 虚函数重写 | 抽象类 | 多态的原理

浮光掠影

已于 2022-07-08 11:47:06 修改

阅读量1.7k

点赞数 29

分类专栏： C++ 文章标签： c++ 开发语言

于 2022-07-02 16:11:52 首次发布

本文链接：https://blog.csdn.net/qq_54851255/article/details/125573973

版权

C++ 专栏收录该内容

17 篇文章 10 订阅

订阅专栏

多态即多种形态。在Linux基础IO一文中@一切皆文件，咱们说过语言上的多态是漫长软件开发过程中探索出的实现“一切皆…”的高级版本。那现在就来了解多态的语法细节。

不要害怕！不要害怕！不要害怕！怕了咱们就先玩儿完了！！

正文开始@一个人的乐队🎸

前置文章：继承；类和对象；指针进阶

反爬链接：

1. 多态

多态分为两类 ——

静态的多态：函数重载。传入不同参数，看起来调用一个函数，但是有不同的行为，最典型的比如流插入流提取的“自动识别类型”。
```
	int i = 10;
	double d = 1.1;
	cout << i; //cout.operator<<(int)
	cout << d; //cout.operator<<(double)
```
动态的多态：一个父类的引用或指针调用同一个函数，传递不同的对象，会调用不同的函数。

所谓静态还是动态在于 ——

静态：在编译时决议，(编译时决定调用谁)
动态：在运行时决议，(运行时决定调用谁)

本文重点讨论的是动态多态。

现在人类有一个买票行为，我们想让不同身份的人，买票的价格不同，就可以借助多态实现。

上层看来我们都是人类，只不过传入对象的身份不同，因买票行为也不同。

这是怎么实现的？这是传子类对象时发生切片，与类型转换无关，否则会产生临时变量，临时变量具有常属性，需要加const

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 p;
	Student s;

	Func(p); //传父类对象 —— 调父类的
	Func(s); //传子类对象 —— 调子类的
	return 0;
}

子类中的函数满足三同(返回值类型、函数名、参数列表完全相同)的虚函数这两个条件，叫做重写(覆盖)。

注：此时函数名相同也不再是所谓的构成隐藏，实际上，父子类的同名函数非重写即隐藏。

这样就做到了，同一函数不同类型的人来做，有不同行为 ——

2. 多态的定义和实现

2.1 多态的条件

💜 多态有两个条件，缺一不可 ——

必须通过基类的指针或者引用调用虚函数，对象没有多态。
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写(底层原理后面看)
- 虚函数：被virtual修饰的类成员函数 ( 准确的说，只有类的非静态成员函数才能是虚函数，其他函数不能成为虚函数，原理虚函数表详谈)
- 重写要求：虚函数 + 三同，总之，这条可以算作四个条件

下面进行一系列验证，first one，若用对象来调用，没有多态 ——

构成多态，传的哪个类型的对象，调用的就是哪个类型的虚函数 - 跟对象有关
不构成多态，调用的就是p类型函数 - 跟类型有关

思考为什么一定要是父类的指针或引用呢？因为这样才能既接收基类对象，又接收子类对象。这样才能在上层看来，“一切皆…”，而在其下各自行为不同。

那父类对象呢？父类对象不也是既能接收基类对象，又接收子类对象吗？yes…但对于引用，会从一而终，没法一会儿父类对象一会儿子类对象；对于指针，

next，若不是虚函数，没有多态，所以调用什么跟p的类型有关 (这跟与隐藏无关，隐藏是针对子类对象调用的而言的) ——

then，破坏参数，也没有多态，所以调用什么跟p的类型有关——

last，返回值不同，破坏多态，直接报错咧？！ ——

它们背后的原理在第5小节详谈。

2.2 虚函数重写的两个例外

虚函数重写条件例外。

2.2.1 协变

协变，返回值是父子关系的指针或引用 （不能是对象），依然可以构成多态。

用处很少。

2.2.2 析构函数的重写

如果析构函数是虚函数，是否构成重写？yes，是因为在继承我们就说过，析构函数名儿被特殊处理了，都处理成了destructor，至于为什么要特殊处理，就是源于多态。

如上我们发现，对于普通对象，不构成多态，都能正确调用：父类的调用父类的；子类的调用子类的，完了自动调用父类的，这我们在继承时候就谈过。就算我不把析构函数写成虚函数，我也不重写，都没关系。你可以自己验证。

but~ 下面这时候就糟了，这也是面试时的高频问题：

💜 那什么场景下，析构函数要是虚函数呢？

如果是动态申请的子类对象，给了父类的指针，若想正确调用，那么析构函数需要是虚函数(右图)

因为如果不是虚函数，不构成多态，那与类型有关，都会去调用父类的析构函数(左图)，但是这样会导致子类对象可能有资源未被清理；我们希望指向父类调用父类的，指向子类调用子类的(完了再调用父类的)，那就需要满足多态的条件，完成重写

当然了，析构函数的重写特简单，它本身函数名“相同”，没参数，自己再加一个virtual就行 ——

其他场景，析构函数是不是虚函数都可以，都可以正确调用析构函数。

当然了，我们推荐在继承体系中，把析构函数写成虚函数。

2.3 只有父类带 virtual 的情况

虚函数，允许父子类两个都是虚函数或 只有父类是虚函数也行。这其实是C++不是很规范的地方，建议两个都写上virtual.

这是因为虽然子类没带virtual，但是它继承了父类的虚函数属性。

大佬这样设计的初衷是，考虑到“析构函数”。。因为在一个巨大的项目中父&子类可能不是一个人儿写的，如果只是父类加了virtual而子类没加，因此不构成多态，没有调用子类析构函数，就可能有内存泄漏问题。

那经过大佬的一番思索，在一个项目中，最好在父类析构函数加上virtual，那么这个漏洞确实就被完完全全的补上了。

但是大佬没有考虑到，这又构成了其他的歧义。令人震惊的事情发生了，如下图，就算Buyticket()是private的，还是继承了父类的属性，能够调的到，震惊！！

不过没关系，我们学完虚表就知道原因了。

建议我们自己写的时候，都加上virtual，肯定不会出错。

2.4 C++11 final & override

2.4.1 final

可以修饰类和重写函数。

💜1. 设计一个不能被继承的类？

在C++11没有引入final时，C++98中通过间接限制，是把父类构造函数设为私有，因为子类一定要调用父类的构造函数要初始化父类的部分，但是private对子类不可见(左图)，因此这样无法实例化子类对象。同时这也带来了问题，父类A也构造不了喂！

这就是要蛋没鸡，要鸡没蛋的问题。。。现在父类构造函数被private修饰，也就是我在类外调不到它(嘘~我在类内还可以调到)，可是成员函数的调用本来又依赖对象，可是我连对象都没有呜呜(我就是想造对象)

我们可以造一个静态成员函数来造对象（右图），在Java中就是经典的静态工厂方法(算了我也不会jvav，那为什么用静态函数呢？因为静态函数的调用不依赖于对象而依赖于类，可以通过类域直接访问。

但是在C++11就优化掉了这个复杂的方法，加final直接限制 ——

💜2. C++11中final还可以限制重写

修饰虚函数，限制它不能被子类中的虚函数重写。

2.4.2 override

override放在子类重写的虚函数后面，帮助检查是否完成重写，没有重写会报错

在Java中有@override来帮助检查 (算了我也不会jvav

3. 重载 vs 重写 vs 隐藏

4. 抽象类

💛 包含纯虚函数的类叫做抽象类(接口类)。在虚函数的后面写上=0 ，则这个函数为纯虚函数。

纯虚函数一般只声明，不实现，抽象类不能实例化出对象。

(它是可以实现的，只不过实现的没有价值。为什么呢？因为，抽象类不能实例化出对象)

哦，那好吧，我总可以定义一个Car的指针/引用来调用函数吧(如下图)。极端一点给一个nullptr，发现可以编译通过，你可能有些震惊，p->Drive();这不是空指针解引用了吗？嘿嘿，这是我们在类和对象 - 隐藏的this指针一文中就讨论过的问题，这只是把nullptr传给了隐藏的this指针而已，并没有发生解引用，所以编译是通过了(我还用p->func();调用普通函数再次验证了这件事儿)

当然了，再看这调用虚函数的p->Drive();看上去是编译通过了，但是运行起来什么也没有打印，这是不是**崩了？**一调试，诶确实崩了。这就关系到后面的虚函数表了，在这里浅说一下，我们调用的这个虚函数地址存放在虚函数表中，虚表指针在对象中，需要通过this指针解引用去找到，这理所当然的崩了；那对于p->func();呢，确实也没崩，因为普通成员函数存放在公共的代码段，不在对象中，不需要this指针去找。

那好吧，既然我也造不出Car父类对象给Car*，那我造一个子类对象，darn it，其派生类继承后也不能实例化出对象(左图)，因为继承了抽象类后，这个派生类就继承了纯虚函数，那它同样也是一个抽象类！

只有重写纯虚函数，派生类才能实例化出对象(右图)。所以呀，抽象类本质上强制继承它的子类完成虚函数重写。

现在就能调用到子类的虚函数了(如右图)

综上，你真没必要去实现纯虚函数，因为实现了，也没人调用你这个父类实现，声明一下即可。

上述提到的这种种现象，你都可以自己实操一下，代码贴给宝子们了 ——

class Car
{
public:
	// virtual void Drive() = 0;
	virtual void Drive() = 0
	{
		cout << "virtual void Drive() = 0" << endl;
	}

	void func()
	{
		cout << "void func()" << endl;
	}
};

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


int main()
{
	Car* p = new Benz;
	p->Drive();
	return 0;
}

什么样的类要设计为抽象类呢？一个类型如果在现实世界中，没有具体的对应实物，就定义为抽象类，这个类没必要实例化出来。这话也够抽象的了(

在Java中，这应该是类似一个叫做“接口”的语法，确实很常用，算了我不在这儿胡说了( 我也不会jvav

override只是在语法上检查是否完成重写。

继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。

5. 多态的原理

5.1 虚函数表

💛 引入

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

	virtual void Func2()
	{
		cout << "Func2()" << endl;
	}
private:
	int _b = 1;
	char _ch = 'A';
};

由结构体对齐规则，我就知道肯定不是8哈哈( ——

在这里插入图片描述

那是多了什么呢？通过监视窗口，发现这个对象多了一个成员，虚函数表指针_vfptr(简称虚表指针) ，所谓的虚函数表就是一个指针数组，里面存放的是函数指针(虚函数地址)，一般这个数组的最后面放了一个nullptr——

在这里插入图片描述
这就实在的解释了我们在抽象类中讨论好久的问题@4

5.2 多态的原理

虚函数表是理解多态原理的关键，下面将集中从原理层解释2.*小节中的现象，以如下代码为例 ——

class Person {
public:
	virtual void BuyTicket() 
	{ cout << "买票-全价" << endl; }
protected:
	int _a = 0;
};

class Student : public Person 
{
public:
	virtual void BuyTicket() 
	{ cout << "买票-半价" << endl; }
protected:
	int _b = 0;
};

void Func(Person& p) {
	p.BuyTicket();
}

int main()
{
	Person Peter;
	Func(Peter);

	Student Mable;
	Func(Mable);

	return 0;
}

虚函数的“重写”也叫“覆盖”，重写是语法上的概念，覆盖是原理层的概念。子类继承父类的虚函数，可以认为深拷贝了一份虚函数表，没重写时，子类与父类虚表完全相同；若重写了，便会用新地址覆盖。这些及建议你都可以，或者你也应该自己打开监视窗口动手验证 (效果已经展示在下下图中了)，代码贴给宝子们了。

转到反汇编可以发现，对于普通成员函数的调用，是在编译后就已经确定了调用地址(橙色的)；却发现，给父类/子类对象，调用虚函数p.BuyTichet();的汇编代码一模一样儿，那一样儿是怎样实现多态的呢？发现此时调用函数时，不再是直接确定地址，而是借助了eax这个寄存器，这是多态原理的关键。

（这段汇编指令不强求看懂，但你应该大胆猜测，这是在去虚表中拿待调用的虚函数地址，放入eax中）

💜 多态的原理：基类的指针/引用指向谁，就去谁的虚函数表中找到对应位置的虚函数进行调用。这是在运行时确定的，所以这叫“动态的多态”。

💛 那现在我们再来反思，为什么一定要是基类的指针或引用类型，而对象不行，对象不是也可以传父类/子类切片吗？@2.1多态的条件

引用切片就是作为给过去的子类的父类部分的别名，它的_vfptr就是理所当然的和子类指向同一空间，哦那就可以实现多态了；
而对象切片，我们打开监视窗口，观察发现相当于拷贝构造。对象的确可以接收父类或子类，但并没有把_vfptr拷贝过来(拷贝过来可就乱了，后面说)，也就是此时这个父类对象的_vfptr仍指向父类虚表，那当然就仍然调用的是父类的虚函数，就算你传参时确实好像发生了子类切片，就算你重写了虚函数，但都没用呀，因此没法实现多态——

同类型的对象虚表指针_vfptr是否一样？是的，同类型的对象，虚表指针指向同一张虚表。

也就是说多个对象共享一个虚函数，虚表中的内容是不允许修改的。

我们总说多态是“运行时多态”，不构成多态时，编译时就会确定调用函数的地址；构成多态，编译时，不能确定调用哪个函数(eax)，它还不知道传的是啥对象，运行时，才确定传入的是父类还是子类对象，去p指向对象的虚表中找到虚函数地址。此时p作为父类对象/子类对象那部分的引用 (指针视角同理，在原理层也是“一切皆…”的视角)。 (不要搞混，编译时是会确定虚函数地址的，不过是运行时再确定填入哪个对象的虚表)。

究竟是怎样？判断的唯一标准就是“是否构成多态”，又回归到构成多态的两个条件(1+4)。

什么？！你说我编译器处理的时候可以把子类的_vfptr强制拷贝过来，这样就能实现多态了？是，但那可就乱了，因为在此之前你可以做任意行为，你都不知道这个对象里存的是父类的虚表还是子类的虚表，会造成混乱的结果：比如一父类对象调用的是子类的析构函数。。。

💛 为什子类么重写虚函数时，设置为private权限，依然能调用到，呈现多态？

因为。。因为编译器是不会检查出来的，它看到的是一个父类调用虚函数p.BuyTicket();，看到的就是父类的publlic接口。子类对象该去虚表中找，能找到就能调用，虚表中也不分公私有。重写是一种“接口继承”。

这么说，C++的访问修饰符不一定安全。。那我能不能通过一些bug的操作，访问到私有的虚函数呢？是可以的。。这个我们在6.1小节会给出。

直接顺着虚表拿到函数地址，这种非常规的操作不受公私有限制。

5.3 虚函数表在哪

普通函数和虚函数存储的位置是否一样？一样的，都在公共代码段，只不过虚函数要把地址存一份到虚表，以实现多态。

那虚表在哪里呢？从前从前，我们就铺垫过虚函数表不能修改，所以我大胆的猜测是在常量区嘿嘿。

我们写一段代码来验证一下 ——

所以，虚函数表是存在“常量区”的。

(在操作系统角度，是不区分常量区和代码段的，都叫代码段。这儿是语言角度)

代码贴给宝子们了 ——

int main()
{
	int* ptr = (int*)malloc(4); 
	printf("heap: %p\n", ptr);

	int a = 0;
	printf("stack: %p\n", &a);

	static int s = 0;
	printf("数据段：%p\n", &s);

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

	printf("代码段：%p\n", &Base::func1);

	Base b;
	// 取对象头4/8个字节 —— 强转(Base* -> int*) —— 再解引用拿到_vfptr
	printf("虚函数表: %p\n", *((int*)&b));

	return 0;
}
//ps: 有一小点代码在上面

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

首先我们要再来观察如下代码在监视窗中的状况，这儿vs起到了很好的误导作用，我们要解释一下，以便后续内容的正常进行，当然了其实并不复杂 ——

class Base 
{
private:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
	void func3() { cout << "Base::func3" << endl; }

private:
	int _a = 0;
};

class Derive : public Base 
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void fun4() { cout << "Derive::func4()" << endl; }
private:
	int _b = 1;
};

int main()
{
	Base b;
	Derive d;
	return 0;  
}

打开监视窗口观察，发现父类对象虚表中如期有两个虚函数地址func1和func2；子类继承父类，可以认为深拷贝了虚函数表，重写func1，覆盖了原来的地址，其中的func2安然不动。

对于子类新增加的虚函数func4，却没看到，是被vs给隐藏了，我们暂且通过内存窗口观察(如下图) ——

令人疑惑的地方又来了，这内存中的Derive::func4怎么跟监视窗的&Derive::func4地址不一样呀。

事实上，虚函数表并不是真实地址，而是这句jmp跳转指令的地址(橙色的)！&Derive::func4这样取到的，即jmp后面跟的地址(绿色的)，才是虚函数的真实地址.

6.0 打印虚函数表

虚表指针是在什么时候初始化的？是在构造函数的初始化列表初始化的。

前文我们就说过，有时虚函数地址被隐藏掉了，之前我们委屈的在内存窗口中观察，现在我们来学习打印虚函数表。

从前从前，我们仔细研究过**“函数指针”如何定义变量**，它与一般int a=0;这样类型后跟名字不同，是混杂在其中的，我们在typedef时，依然保留了这个原则。

我们已经熟知，虚表是一个函数指针数组，打印它并不难，这个经验来自于我们学习Linux环境变量时打印过环境表、命令行参数数组 ——

typedef void(*VF_PTR)(); //类型重定义：(虚)函数指针

void VFTable(VF_PTR table[])
{
	for (int i = 0; table[i] != nullptr; i++)
	{
		printf("vft[%d]: %p\n", i, table[i]);
	}
}

那么在调用这个函数的时候，就需要传入虚函数表的地址，即指针数组的(首元素)地址，即对象中的虚表指针_vfptr。

问题就转化成了如何**取到对象头4/8个字节**呢？

嗯…没法直接转成int，那取&个地址，指针的类型决定看待内存的视角，如果强转为(int*)，再解引用拿的就是头四个字节。可是传入的参数类型还不匹配，那就再(VF_PTR*)强转一下 ——

	Base b;
	PrintVFTable((VF_PTR*)(*(int*)&b));

嗯如果你直接看这一坨当然会有些眼晕，但其实只要你能稍稍的独立思考就很很很简单！

（注：vs有一些bug，你一打印可能打印出了很多无关地址，可以清理一下解决方案；或者通过函数地址来手动调用函数验证，方法如下）

typedef void(*VF_PTR)(); //(虚)函数指针

void PrintVFTable(VF_PTR table[])
{
	for (int i = 0; table[i] != nullptr; i++)
	{
		printf("vft[%d]: %p -> ", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

是的，在尝试写它的时候，我就感受到这有多bug。。按理来说，这些函数都要通过对象调用，传入this指针，受到访问修饰限定；但是在这儿，我都没搞，就直接拿着函数地址调用。。也就是说此时this指针是一个随机值，如果访问成员就可能出现一些越界访问，打印出随机值甚至崩溃。。

我们也完全可以通过这种bug的方式，访问到私有虚函数，所以虚表是有安全隐患的。。

	Base b;
    PrintVFTable((VF_PTR*)(*(int*)&b));			// 32位
	PrintVFTable((VF_PTR*)(*(long long*)&b));	// 64位

32位平台，用(int*)强转。
64位平台，用(long long*)强转。用double好像行但其实不太行，因为会有精度丢失 ( double在内存中确实占了64个字节，但是double类型的有效位M只有52位，虽然我们把取出的数字按照地址看待，但是和double转int同理)

震惊的是在32位平台下，用(long long*)强转的居然还能正常跑。。

是因为之后再用(VF_PTR*)这个函数指针强转，8字节恰好截断到头上4字节。

💛 我们想要探索出，32/64位平台下能自适应的方式 ——

	Base b;
	PrintVFTable((VF_PTR*)(*(int*)&b));			// 32位
	PrintVFTable((VF_PTR*)(*(long long*)&b));	// 64位
	PrintVFTable((VF_PTR*)(*(void**)&b));		// 32/64位

怎么忽然就是是void**呢？(int*) 解引用看一个int的大小，(long long*)解引用看的是long long的大小，void* 不能解引用，这(void**)解引用看的是void* 的大小，void* 的大小就和平台相关。

当然了，这样说char** /int** 什么的都可以，只要是二级指针都可以。

💛 也可以条件编译 ——

	Base b;
#ifdef _WIN64
	PrintVFTable((VF_PTR*)(*(long long*)&b));
#else
	PrintVFTable((VF_PTR*)(*(int*)&b));
#endif

注：_WIN32：Defined for applications for Win32 and Win64. Always defined. 不能用于判断平台环境。

_WIN64：Defined for applications for Win64.

那好嘞，我们现在就能方便的看一看子类虚表了。

6.1 单继承的虚函数表

代码贴给宝子们了，你最好，哦不，你也应该自己验证一下 ——

class Base 
{
private:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int _a = 0;
};

class Derive :public Base 
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	void fun4() { cout << "func4()" << endl; }
private:
	int _b = 1;
};

int main()
{
	Base b;
	PrintVFTable((VF_PTR*)(*(void**)&b));

	Derive d;
	PrintVFTable((VF_PTR*)(*(void**)&d));

	return 0;
}

重写的fuc1，拷贝继承下来的func2，自己的func3 ——

6.2 多继承的虚函数表

代码贴给宝子们了，你最好，哦或者说，你也应该自己验证一下 ——

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int _b1 = 0;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int _b2 = 0;
};

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

int main()
{
	Derive d;

	Base1* p1 = &d;
	p1->func1();

	Base2* p2 = &d;
	p2->func1();

	return 0;
}

打开监视窗口观察，此时Derive对象中理所当然的有两个虚表，并且即使子类重写了func1后，你发现这对象虚表中，Base1和Base2的虚函数func1的地址不一样，你早就不应该感到惊奇，因为这时jmp跳转指令的地址，最终会一跳到同一位置执行函数Derive::func1的 ——

发现p2->func1()调用函数时，还跳了好多层。这是为了做准备工作ecx-8 ，修正this指针(eax)，为什么呢？调用虚函数时，要传递this指针，-8由指向Base1到指向Base2，从而看到对应类型视角下的那部分。当然，这你了解即可。

💜 我们需要打印虚函数表，来观察多继承下的对象模型：

由于子类中有两份虚表，我们需要再认真思考如何传入第二个虚表指针_vfptr ——

（建议，哦不，你也应该独立思考，因为你直接看下面这一坨肯定会眼晕，当然了，我就是知道你会眼晕，所以我好好给你解释）

int main()
{
	Base1 b1;
	PrintVFTable((VF_PTR*)(*(void**)&b1));

	Base2 b2;
	PrintVFTable((VF_PTR*)(*(void**)&b2));

	cout << "_____________________________________" << endl;
	Derive d;
	PrintVFTable((VF_PTR*)(*(void**)&d));
    /*打印第二个虚函数表*/
    PrintVFTable((VF_PTR*)(*(void**)((char*)&d+sizeof(Base1))));

	return 0;
}

切片时会引起指针的自动偏移，可以直接打印:) ——

    Base1* p1 = &d;
	Base2* p2 = &d; // 切片 - 也干了类似 (char*)&d+sizeof(Base1) 这样的操作
	PrintVFTable((VF_PTR*)*((void**)p2));

当然了，在汇编角度它一定也做了我们手动移动类似的事情。

💛 发现多继承时，子类自己的虚函数Derive::func3只放在第一个父亲的虚表中 ——

你可以把Base2放到前面试试。

6.3 菱形继承的虚函数表

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。可以去看下面的两篇链接：

C++ 虚函数表解析 | 酷壳 - CoolShell

C++ 对象的内存布局 | 酷壳 - CoolShell

当然了，还是简单跟宝子们说说，来一段老朋友代码，打开监视窗口 ——

class A
{
public:
	virtual void f()
	{}
public:
	int _a;
};

class B : virtual public A 
{
public:
	int _b;
};

class C : virtual public A 
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	//d._a = 0; //不存在二义性，可以直接找
	return 0;
}

另外，在钻石型继承中，如果B和C都重写了A的虚函数func1，那么D必须重写func1，否则会报错“D”:“void A::f1(void)”的不明确继承，因为这儿是虚继承，共用一个虚表，不知道用哪个重写，看如下代码：

public:
	virtual void f1() {}
public:
	int _a;
};

class B : virtual public A 
{
public:
	virtual void f1() {}
	virtual void f2() {}
public:
	int _b;
};

class C : virtual public A 
{
public:
	virtual void f1() {}
	virtual void f2() {}
public:
	int _c;
};

class D : public B, public C
{
public:
	virtual void f1() {}
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

在继承中**@7.3 菱形继承的原理**，我们说过虚基表中，曾经内容是00000000是为其他东西预留的，那它究竟是什么呢？这是找虚表的偏移量。

还是挺麻烦的，所以你没事儿别定义菱形继承（

7. 总结

来几道经典的问答题小伙子小姑娘？！不完全给答案是为了让你别背~

什么是多态？
什么是重载、重写(覆盖)、重定义(隐藏)？
多态的实现原理？
inline函数可以是虚函数吗？

准确的说不可以，因为内联函数没有地址，但是虚函数地址要被填入到虚表中。不过是可以编译通过的，因为inline只是个建议，到底有没有展开要视情况而定：若调用时不构成多态，保持inline属性；若构成多态，则没有inline属性。
静态成员函数可以是虚函数吗？ 不可以，会直接报错“virtual”不能和"static"一起使用。
因为静态成员函数没有this指针，只能使用类型::成员函数的调用方式，这样无法构成多态，而虚函数的价值就在于重写后构成多态。
构造函数可以是虚函数吗？ nope
同样的，构造函数设为虚函数没有价值，虚函数的意义就在于构成多态调用。多态调用就要去虚函数表中查找虚函数，这又涉及先有鸡还是先有蛋的问题，因为对象中的虚表中的虚函数指针，就是在构造函数初始化列表阶段才初始化的。
析构函数可以是虚函数吗？ 什么场景下析构函数必须是虚函数？

yes，并且继承体系中推荐写成虚函数。
对象访问普通函数更快还是虚函数更快？要看是否构成多态。
如果不构成多态，那都是编译时确定调用函数的地址，一样快；如果构成多态，那么虚函数调用是运行时虚函数表中确定函数地址，普通函数编译时直接确定地址，则普通函数更快。
虚函数表是在什么阶段生成的？存在于哪？

注：别把虚基表和虚函数表搞混了。编译阶段；常量区。
C++菱形继承的问题？虚继承原理？
什么是抽象类？抽象类的作用？