C++ 面向对象特性：多态、虚表、多继承

1、什么是多态

多态包括两种，静态多态和动态多态。

·静态多态：函数重载和运算符重载，对函数名的复用，在编译阶段确定函数地址。

·动态多态：由派生类和虚函数实现运行时多态，在运行阶段确定函数地址。

多态可以让同名函数，因为函数指向的对象不同，而调用该对象中该名称的函数。

在动态多态中，操作系统给构成多态的每个类增加了一个虚函数表，表中存放virtual关键词用来修饰虚函数的首地址。编译器运行时通过首地址去调用对应的函数，以此形成多态。

2、如何验证虚表的存在

创建两个相同的类，一个实现多态，一个不实现多态，实例化对象后打印该类的大小。

#include <iostream>
using namespace std;

class Base1 {
public:
	void func1() {};
private:
	int a;
};

class Base2 {
public:
	virtual void func1() {};
private:
	int a;
};

int main() {
	Base1 b1;
	Base2 b2;

	cout << "Base1的大小：" << sizeof(b1) << endl;
	cout << "Base2的大小：" << sizeof(b2) << endl;

	return 0;
}

由图中可以看出，有虚函数的类比没有虚函数的类多了12个字节。

至于为什么多了12个字节时因为我使用的时64位系统，指针的大小为8个字节，int类型为4个字节，由于内存对齐进行了4个字节的填充，因此为16字节。如果是在32位系统中，将会输出8。

3、如何打印虚表中函数的地址

虚函数表本质上是一个存储虚函数指针的数组，可以使用指向函数指针的指针来接收虚表的地址。

#include <iostream>
using namespace std;

class Base {
public:
	virtual void func1() {
		cout << "Base::func1: ";
	}
	virtual void func2() {
		cout << "Base::func2: ";
	}
};

class Son : public Base {
public:
	virtual void func1() {
		cout << "Son::func1: ";
	}
	virtual void func3() {
		cout << "Son::func3: ";
	}
};

typedef void(*Func)();// 表示Fun是指向函数的指针，Fun*表示指向函数指针的指针

void MyPrint(Func* vtable) {
	cout << "虚表地址：" << vtable << endl;
	for (int i = 0; vtable[i] != nullptr; ++i) {
		vtable[i]();
		cout << (void*)vtable[i] << endl;
	}
	cout << endl;
}

int main() {
	Base b;
	Son s;

	// 获取虚表指针并打印地址
	Func* vtable1 = *(Func**)&b;
	MyPrint(vtable1);

	Func* vtable2 = *(Func**)&s;
	MyPrint(vtable2);

	return 0;
}

运行结果表明：

父类和子类中都有一个虚表存放了虚函数的地址，如果子类重写了父类虚函数，则地址也会不一样，如func1所示。如果没有重写，地址则一样，如func2所示。子类新创建的虚函数为func3。

4、多继承时的虚函数表的特点

如上文所示，单继承时，父类和子类各有一张虚表。而多继承时，子类会根据继承的父类数量存储对应数量的虚表，每张虚表来自不同的父类。

#include <iostream>
using namespace std;

class Base1 {
public:
	virtual void func1() {
		cout << "Base1::func1: ";
	}
	virtual void func2() {
		cout << "Base1::func2: ";
	}
};

class Base2 {
public:
	virtual void func1() {
		cout << "Base2::func1: ";
	}
	virtual void func2() {
		cout << "Base2::func2: ";
	}
};

class Son : public Base1, public Base2 {
public:
	virtual void func1() {
		cout << "Son::func1: ";
	}
	virtual void func3() {
		cout << "Son::func3: ";
	}
};

typedef void(*Fun)();// 表示Fun是指向函数的指针，Fun*表示指向函数指针的指针

void MyPrint(Fun* vtable) {
	cout << "虚表地址：" << vtable << endl;
	for (int i = 0; vtable[i] != nullptr; ++i) {
		vtable[i]();
		cout << vtable[i] << endl;
	}
	cout << endl;
}


int main() {
	Son s;

	// 获取虚表1指针并打印地址
	Fun* vtable = *(Fun**)&s;
	MyPrint(vtable);

	// 获取虚表2指针并打印地址
	vtable = *(Fun**)((char*)&s + sizeof(Base1));
	MyPrint(vtable);

	return 0;
}

运行结果表明：

子类率先继承的父类虚表在前，后继承的父类虚表在后。子类中出现了父类没有的虚函数，则地址默认放在第一张虚表中。

我们发现，同为Son::func1，地址却不一样，这是因为虚表2中并没有直接储存Son::func1的地址。在调用Son::func1时，会去第一张虚表里面找。