开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> 【C++】多态 —— 条件 | 虚函数重写 | 抽象类 | 多态的原理 -> 正文阅读

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

多态即多种形态。在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;
}