C++ 之多态【虚函数表、多态的原理、动态绑定与静态绑定】

前言

1.多态的原理

1.1虚函数表

1.2派生类中的虚表

1.3虚函数、虚表存放位置

1.4多态的原理

1.5多态条件的思考

2.动态绑定与静态绑定

3.单继承和虚继承中的虚函数表

3.1单继承中的虚函数表

3.2多继承(非菱形继承)中的虚函数表

4.问答题

前言

需要声明的，这期博客的代码及解释都是在vs202022下的x86程序中，涉及的指针都是4bytes。如果要其他平台下，部分代码需要改动。比如：如果是x64程序，则需要考虑指针是8bytes问题等等

1.多态的原理

1.1虚函数表

这里常考一道笔试题：sizeof(Base)是多少

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

int main()
{
	Base b;
	cout << sizeof(b) << endl;
	return 0;
}

8字节说明了，对象中除了存储成员变量_b，还存储着些什么

有一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)

一个含有虚函数的类中都至少有一个虚函数表指针

因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

1.2派生类中的虚表

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)基类对象包含一个虚函数表指针（vptr），指向基类的虚函数表

派生类对象同样包含一个vptr，指向派生类的虚函数表，

在派生类对象的内存布局上，

派生类对象的虚表指针覆盖了所包含的基类子对象的虚表指针，指向的是派生类的虚函数表

即派生类的虚表指针存放到了所包含的基类子对象虚表指针的位置

(2)基类b对象和派生类d对象虚表是不一样的，

这里我们发现Func1完成了重写，所以d的虚表中存储的是重写的Derive::Func1

所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。

重写是语法层的叫法，覆盖是原理层的叫法

(3)另外Func2继承下来后是虚函数，所以放进了虚表

Func3也继承下来了，但不是虚函数，所以不会放进虚表

(4)虚函数表本质是一个存虚函数指针的函数指针数组

一般情况这个数组最后面放了一个nullptr

(5)总结一下派生类的虚表生成：

a.派生类首先会继承基类的虚函数表结构

b.派生类重写了基类中的某个虚函数

就用派生类的虚函数地址覆盖虚表中基类的虚函数地址

c.派生类自己新增加的虚函数按其在派生类中的声明次序追加到派生类虚表的最后

1.3虚函数、虚表存放位置

虚函数与普通函数一样，存放在代码段中

虚函数表的存放位置由编译器决定，不同的编译器可能有不同的实现方式

下面是在vs2022 X86环境下运行的代码及结果，推断虚表存放在常量区(只读数据段)
//验证虚表存放在常量区(代码段)
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	char _b = 1;
};

int main()
{
	int a = 10;
	printf("栈：%p\n", &a);

	int* b = new int(5);
	printf("堆：%p\n", b);

	static int c = 20;
	printf("静态区：%p\n", &c);

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

	Base b;
	printf("虚表地址：%p\n", *((int*)&b));
	return 0;
}

所以同一个类的对象共用同一张虚表

1.4多态的原理

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl;}
protected: int a = 10;
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl;}
protected: int b = 20;
};
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

这样就实现出了不同对象去完成同一行为时，展现出不同的形态

多态的原理就是根据指向的对象类型使用该对象的虚表指针找到到该对象的虚表然后再在虚表中去找到并调用相应函数(如果有)

1.5多态条件的思考

(1)多态要求必须通过父类的指针或引用实现：

因为父类的指针既可以指向父类对象也可以指向子类对象

指向父类对象时就在父类对象的虚表中去找到相应函数并调用(如果有)

指向子类对象时就在子类对象的虚表中去找到相应函数并调用(如果有)

同理父类的引用可以是父类对象的别名也可以是子类对象的别名

是父类对象的别名时就在父类对象的虚表中去找到相应函数并调用(如果有)

是子类对象的别名时就在子类对象的虚表中去找到相应函数并调用(如果有)

不能是父类对象的原因是:

赋值切片时，虚表并不进行拷贝，此时通过父类对象只能调用父类的虚函数

假设虚表要进行拷贝，那么会导致父类对象调用的虚函数不明确

(既可能是父类对象的虚函数也可能是子类对象的虚函数)

(2)多态要求实现虚函数的重写:
只有实现了虚函数的重写，才能实现相同函数名调用时出现不同的形态

2.动态绑定与静态绑定

class person {
public:
	virtual void buyticket() 
	{ 
		cout << "买票-全价" << endl;
	}
protected:
	int a = 10;
};
class student : public person {
public:
	virtual void buyticket() 
	{ 
		cout << "买票-半价" << endl;
	}
protected:
	int b = 20;
};
void func(person* p)
{
	p->buyticket();
}
int main()
{
	person mike;
	func(&mike);

	mike.buyticket();
	return 0;
}

满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的

不满足多态的函数调用，在编译时确定

1.静态绑定又称为前期绑定(早绑定)

是指在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载、模板等

2. 动态绑定又称后期绑定(晚绑定)

是指在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，

也称为动态多态，比如：构成多态条件的虚函数的调用等

3.单继承和虚继承中的虚函数表

3.1单继承中的虚函数表

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a = 10;
};
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 = 20;
};

int main()
{
	Base b1;
	Derive d1;

	return 0;
}

通过监视窗口，我们发现d1虚表当中似乎没有追加自身虚函数的地址

但通过内存窗口，我们可以看到虚表中存放有四个指针，我们打印出来看看

接上面的代码
//给函数指针起个别名
typedef void(*FUNC_VFT)();

void Print(FUNC_VFT* table)
{
	for (int i = 0; table[i] != nullptr; ++i)
	{
		printf("[%d]:%p->", i, table[i]);
		FUNC_VFT f = table[i];
		f();
	}
	printf("\n");
}
int main()
{
	Base b1;
	Derive d1;
	//取到虚表指针，虚表指针本质是一个函数二级指针
	FUNC_VFT* table = (FUNC_VFT*)(*((int*)&d1));

	Print(table);

	return 0;
}

我们看到，派生类的虚表确实在末尾追加了自己定义的虚函数地址

关于上面验证的细节:

(1) 认识到虚表本质上是一个函数指针数组，虚表指针就是一个函数二级指针

(1) 函数指针看起来比较复杂，起个别名更简便

(1) 对象的前四个字节存放的是虚表指针(不同平台不一样)

(1) for循环中，虚表末尾通常放一个nullptr(不同平台可能不一样，此时则需要定死循环次数)

同时，在vs下，你在编译好的情况下再次修改代码，nullptr可能就会消失，这时候只需要重写生成解决方案即可

(1) 关于函数调用，这里的情况非常特殊，成员函数没有参数，且没有调用this指针

不然的话就会大坑

(1) 当然，调用的虚函数打印的话也在此次验证中起到了举足轻重的作用

3.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;
	
	return 0;
}

对象d分别继承两个基类的虚表结构，完成虚函数的覆盖

只是同样看不见自己的func3存放到哪里，打印出来看看

int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	//VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	Base2* p = &d;
	VFPTR* vTableb2 = (VFPTR*)(*(int*)p);
	PrintVTable(vTableb2);
	return 0;
}

存放到了Base1的虚表当中

结论就是：多继承派生类自身的虚函数追加第一个继承基类部分的虚函数表末尾

这保持了与单继承的一致性

简化了多态调用的实现(第一个基类指针直接调用无需偏移量调整)

调用d对象中的func1函数

两张虚表当中都有func1函数，但fun1函数的地址只有一个

编译器针对func1函数的调用，首先需要传this指针，其次call 函数func1的地址

子类包含的第一个父类子对象的地址与派生类对象的地址相同，

使用第一个父类指针调用func1时，传完该指针之后可以直接调用func1

子类类包含的第一个父类子对象的地址与派生类对象的地址相同，

使用第二个父类指针调用func1时，传完该指针之后需修正使其指向派生类对象的地址，最后进行调用

4.问答题

4. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是 inline，因为虚函数要放到虚表中去。

5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。