什么是虚函数表?
每个包含了虚函数的类都有一个虚函数表(简称虚表)。
虚表是一个指针数组,其元素是虚函数的指针,每个元素对应一个虚函数的函数指针。
需要指出的是,普通的函数即非虚函数,其调用并不需要经过虚表,所以虚表的元素并不包括普通函数的函数指针。
虚函数指针的赋值发生在编译器的编译阶段,也就是说在代码的编译阶段,虚表就可以构造出来了。
如下代码,类 A 包含虚函数vfunc1
,vfunc2
,由于类 A 包含虚函数,故类 A 拥有一个虚表。
class A {
public:
virtual void vfunc1();
virtual void vfunc2();
void func1();
void func2();
private:
int m_data1, m_data2;
};
类A的虚表如图所示:
虚表是属于类的,而不是属于某个具体的对象,一个类只需要一个虚表即可。同一个类的所有对象都使用同一个虚表。
为了指定对象的虚表,对象内部包含一个虚表的指针,来指向自己所使用的虚表。为了让每个包含虚表的类的对象都拥有一个虚表指针,编译器在类中添加了一个指针,*__vptr
,用来指向虚表。这样,当类的对象在创建时便拥有了这个指针,且这个指针的值会自动被设置为指向类的虚表。
动态绑定
如下例子:
class A {
public:
virtual void vfunc1();
virtual void vfunc2();
void func1();
void func2();
private:
int m_data1, m_data2;
};
class B : public A {
public:
virtual void vfunc1();
void func2();
private:
int m_data3;
};
class C: public B {
public:
virtual void vfunc2();
void func2();
private:
int m_data1, m_data4;
};
类 A 是基类,类 B 继承类 A,类 C 又继承类 B。当一个类继承另一个类时,也会继承基类的函数的调用权。所以如果一个基类包含了虚函数,那么其继承类也可调用这些虚函数,换句话说,一个类继承了包含虚函数的基类,那么这个类也拥有自己的虚表。
类 A,类 B,类 C,其对象模型如下图 3 所示。
由于这三个类都有虚函数,故编译器为每个类都创建了一个虚表,即类 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 的虚表。当我们使用p
来调用vfunc1()
函数时,会发生什么现象?
int main() {
B bObject;
A *p = & bObject;
p->vfunc1();
}
程序在执行p->vfunc1()
时,会发现p
是个指针,且调用的函数是虚函数,接下来便会进行以下的步骤。
首先,根据虚表指针p->__vptr
来访问对象bObject
对应的虚表。虽然指针p
是基类A*
类型,但是由于B继承A,类B的*__vptr
也是基类A的一部分,所以可以通过p->__vptr
可以访问到对象对应的虚表。
然后,在虚表中查找所调用的函数对应的条目。由于虚表在编译阶段就可以构造出来了,所以可以根据所调用的函数定位到虚表中的对应条目。对于 p->vfunc1()
的调用,B vtbl 的第一项即是vfunc1
对应的条目。最后,根据虚表中找到的函数指针,调用函数。从图可以看到,B vtbl 的第一项指向B::vfunc1()
,所以 p->vfunc1()
实质会调用B::vfunc1()
函数。
如果p
指向类 A 的对象,情况又是怎么样?
int main() {
A aObject;
A *p = &aObject;
p->vfunc1();
}
当aObject
在创建时,它的虚表指针__vptr
已设置为指向 A vtbl,这样p->__vptr
就指向 A vtbl。vfunc1
在 A vtbl 对应在条目指向了A::vfunc1()
函数,所以 p->vfunc1()
实质会调用A::vfunc1()
函数。
可以把以上三个调用函数的步骤用以下表达式来表示:
(*(p->__vptr)[n])(p)
可以看到,通过使用这些虚函数表,即使使用的是基类的指针来调用函数,也可以达到正确调用运行中实际对象的虚函数。
我们把经过虚表调用虚函数的过程称为动态绑定,其表现出来的现象称为运行时多态。动态绑定区别于传统的函数调用,传统的函数调用我们称之为静态绑定,即函数的调用在编译阶段就可以确定下来了。
那么,什么时候会执行函数的动态绑定?这需要符合以下三个条件。
- 有继承关系
- 子类重写父类中的虚函数
- 父类指针或引用指向子类对象
如果一个函数调用符合以上三个条件,编译器就会把该函数调用编译成动态绑定,其函数的调用过程走的是上述通过虚表的机制。