多态的实现

多态的实现

为了实现C++的多态，C++使用了一种动态绑定的技术。这个技术的核心是虚函数表。下面介绍虚函数表是如何实现动态绑定的。

类的虚函数表

• 每个包含了虚函数的类都包含一个虚表（存放虚函数指针的数组）。
• 当一个类（B）继承另一个类（A）时，类B会继承类A的函数的调用权。所以如果一个基类包含了虚函数，那么其继承类也可调用这些虚函数，换句话说，一个类继承了包含虚函数的基类，那么这个类也拥有自己的虚表。
• 以下的代码。类A包含虚函数vfunc1，vfunc2，由于类A包含虚函数，故类A拥有一个虚表。

#include<iostream>

using namespace std;

class A
{
public:
	virtual void vfunc1();
	virtual void vfunc2();
	void func1();
	void func2();
private:
	int m_data1;
	int m_data2;
};

class B :public A {}; //此时类B也拥有自己的虚表

类A的虚表如图所示：

• 虚表是一个存放指针的数组，其内的元素是虚函数的指针，每个元素对应一个虚函数的函数指针。需要指出的是：普通的函数即非虚函数，其调用并不需要经过虚表，所以虚表的元素并不包括普通函数的函数指针。
• 虚表内的条目，即虚函数指针的赋值发生在编译器的编译阶段，也就是说在代码的编译阶段，虚表就可以构造出来了。

虚表指针

• 虚表是属于类的，而不是属于某个具体的对象，一个类只需要一个虚表即可。同一个类的所有对象都使用同一个虚表。
• 为了指定对象的虚表，对象内部包含一个虚表的指针，来指向自己所使用的虚表。为了让每个包含虚表的类的对象都拥有一个虚表指针，编译器在类中添加了一个指针，*__vptr，用来指向虚表。这样，当类的对象在创建时便拥有了这个指针，且这个指针的值会自动被设置为指向类的虚表。
• 验证_vptr指针的方法（_vptr指针不可访问），就是先求一个普通类占的字节数大小sizeof()，然后将类中某一个函数（方法）前加virtual关键字变为虚函数，再求该类占的字节数大小sizeof()，会发现增加4个字节，这就验证了vptr的存在。

动态绑定

动态联编（动态绑定）是指编译程序在编译阶段并不能确切地知道将要调用的函数，只有在程序执行时才能确定将要调用的函数，为此要确切地知道将要调用的函数，要求联编工作在程序运行时进行，这种在程序运行时进行的联编工作称为动态联编。

C++规定：动态联编是在虚函数的支持下实现的。

动态联编必须包括以下方面：

• 成员函数必须声明为virtual
• 如果基类中声明了为虚函数，则派生类不必再声明。

调用方式：通过对象的指针或引用调用成员函数，或通过成员函数调用，反之就无法实现动态联编。

特点：灵活，问题的抽象性和问题的易维护性。

class A
{
public:
	virtual void vfunc1();
	virtual void vfunc2();
	void func1();
	void func2();
private:
	int m_data1;
	int m_data2;
};

class B :public A
{
public:
	virtual void vfunc1();
	void func1();
private:
	int m_data3;
};

class C :public B
{
public:
	virtual void vfunc2();
	void func2();
private:
	int m_data1;
	int m_data4;
};

• 由于这三个类都有虚函数，故编译器为每个类都创建了一个虚表，即类A的虚表（A vtbl），类B的虚表（B vtbl），类C的虚表（C vtbl）。类A，类B，类C的对象都拥有一个虚表指针，*__vptr，用来指向自己所属类的虚表。
• 类A包含两个虚函数，故A vtbl包含两个指针，分别指向A::vfunc1()和A::vfunc2()。
• 类B继承于类A，故类B可以调用类A的函数，但由于类B重写了B::vfunc1()函数，故B vtbl的两个指针分别指向B::vfunc1()和A::vfunc2()。
• 类C继承于类B，故类C可以调用类B的函数，但由于类C重写了C::vfunc2()函数，故C vtbl的两个指针分别指向B::vfunc1()（指向继承的最近的一个类的函数）和C::vfunc2()。
• 只要抓住“对象的虚表指针用来指向自己所属类的虚表，虚表中的指针会指向其继承的最近的一个类的虚函数”这个特点，便可以快速将这几个类的对象模型在自己的脑海中描绘出来。
• 非虚函数的调用不用经过虚表，故不需要虚表中的指针指向这些函数。

假设我们定义一个类B的对象。由于bobject是类B的一个对象，故bobject包含一个虚表指针，指向类B的虚表。

int main()
{
	B bobject;
}

现在，我们声明一个类A的指针p来指向对象oboject。虽然p是基类的指针只能指向基类部分，但是虚表指针也属于基类部分，所以p可以访问到对象bobject的虚表指针。bobject的虚表指针指向类B的虚表，所以p可以访问到B vtbl。

int main()
{
	B bobject;
	A* p = &bobject; //父类指针指向子类对象
}

当我们使用p来调用vfunc1()函数时，会发生什么现象呢？

int main()
{
	B bobject;
	A* p = &bobject; //父类指针指向子类对象
	p->vfunc1();
}

• 程序在执行p->vfunc1()时，会发现p是个指针，且调用的函数是虚函数，接下来便会进行以下的步骤。
• 首先，根据虚表指针p->vptr来访问对象bobject对应的虚表。虽然指针p是基类类A类型，但是vptr也是基类的一部分，所以可以通过p->__vptr可以访问到对象对应的虚表。
• 然后，在虚表中查找所调用的函数对应的条目。由于虚表在编译阶段就可以构造出来了，所以可以根据所调用的函数定位到虚表中的对应条目。对于p->vfunc1()的调用，B vtbl的第一项即是vfunc1对应的条目。
• 最后，根据虚表中找到的函数指针，调用函数。B vtbl的第一项指向B::vfunc1()，所以p->vfunc1()实质会调用B::vfunc1()函数。

#include<iostream>

using namespace std;

class A
{
public:
	virtual void vfunc1()
	{
		cout << "father eat" << endl;
	}
};

class B :public A
{
public:
	virtual void vfunc1() //在继承关系下，vfunc1前面不写virtual，它也是虚函数
	{
		cout << "child eat" << endl;
	}
};

int main()
{
	A* a = new B();
	a->vfunc1();
	return 0;
}