虚函数及虚函数表_一个类有几个虚函数表

虚函数及虚函数表

各个类对象共享类的虚函数表，每个类对象有个虚函数指针vptr，虚函数指针vptr指向虚函数表（对于只有一个虚函数表的情况）。

虚函数

简单的说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类的所有虚函数对应的函数指针。

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

虚函数表

虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其内容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。没关系，下面就是实际的例子，相信聪明的你一看就明白了。

假设我们有这样的一个类：

class Base {

public:

virtual void f() { cout << “Base::f” << endl; }

virtual void g() { cout << “Base::g” << endl; }

virtual void h() { cout << “Base::h” << endl; }

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。下面是实际例程：

typedef void(*Fun)(void);

Base b;

Fun pFun = NULL;

cout << “虚函数表地址：” << (int*)(&b) << endl;

cout << “虚函数表 — 第一个函数地址：” << (int*)*(int*)(&b) << endl;

// Invoke the first virtual function

pFun = (Fun)*((int*)*(int*)(&b));

pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0); // Base::f()

(Fun)*((int*)*(int*)(&b)+1); // Base::g()

(Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

简单地说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类所有的虚函数对应的函数指针。

单继承（无虚函数覆盖）

class Base {

public:

      virtual void f() { cout << “Base::f()” << endl; }

      virtual void g() { cout << “Base::g()” << endl; }

      virtual void h() { cout << “Base::h()” << endl; }

};

class Derive :public Base {

public:

      virtual void f1() { cout << “Derive::f1()” << endl; }

      virtual void g1() { cout << “Derive::g1()” << endl; }

      virtual void h1() { cout << “Derive::h1()” << endl; }

};

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

单继承（有虚函数覆盖）

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

class Base {

public:

      virtual void f() { cout << “Base::f()” << endl; }

      virtual void g() { cout << “Base::g()” << endl; }

      virtual void h() { cout << “Base::h()” << endl; }

};

class Derive :public Base {

public:

      virtual void f() { cout << “Derive::f()” << endl; }

      virtual void g1() { cout << “Derive::g1()” << endl; }

      virtual void h1() { cout << “Derive::h1()” << endl; }

};

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序， 

Base *b = new Derive(); 

b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

多重继承（无虚函数覆盖）

当一个类继承多个类，且多个基类都有虚函数时，子类对象中将包含多个虚函数表的指针（即多个vptr）。

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

1）每个父类都有自己的虚表。

2）子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多重继承（有虚函数覆盖）

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如： 

Derive d;

Base1 *b1 = &d;

Base2 *b2 = &d;

Base3 *b3 = &d;

b1->f(); //Derive::f()

b2->f(); //Derive::f()

b3->f(); //Derive::f()

b1->g(); //Base1::g()

b2->g(); //Base2::g()

b3->g(); //Base3::g()

虚函数表的内存布局

虚表其实在数据段。

对于一个具体类型来说，它的行为是确定的，即对于同一个类型的所有实例，它们的虚函数表的内容相同，在编译时可以确定。因此，如果把虚函数表的全部内容附着在对象实例上，这样的对象模型显然是浪费内存的。因此，在对象实例起始处，放的是一个指针，指向其虚函数表，因此每个对象的虚函数表在实例中仅占一个指针（4 bytes / 32位系统）空间。如果一个类型有多个实例，它们指向的是同一份虚函数表（典型情况是位于进程空间的 .rdata section）。虚函数表指针的初始化由编译器生成的各种构造函数负责。如果一个函数不包含虚函数，则对象实例中不包含虚函数表指针。虚函数表可以认为是由函数指针组成的数组，数组元素由该类型的所有虚函数的地址组成，用 NULL 表示结尾（取决于编译器对模型的实现）。如果该类型实现了自己的虚函数，它将覆盖从父类继承下来的元素。编译器知道表中每个元素对应是那个虚函数，因此调用时取出元素，通过 call 指令实现调用。观察 VC debug 版本的汇编代码，虚函数表的内容被编译到只读的 section（和其他常量字符串一起），每个元素代表的是函数的地址（这些元素是代码段起始部的一组 jump 语句的地址，类似中断向量表，用于跳到真正的函数体）。由于虚函数表位于只读 section 中，所以其元素（函数指针）是不能直接改写的。

​​​​​​​示例精讲

class A {

public:

    virtual void vfunc1();

    virtual void vfunc2();

            void func1();

            void func2();

private:

    int m_data1, m_data1;

};

class B : public A {

public:

    virtual void vfunc1();

            void func2();

private:

    int m_data3;

};

class C : public B {

public:

    virtual void vfunc1();

            void func2();

private:

    int m_data1, m_data4;

};

以上三个类在内存中的排布关系如下图所示：

1. 对于非虚函数，三个类中虽然都有一个叫 func2 的函数，但他们彼此互不关联，因此都是各自独立的，不存在重载一说，在调用的时候也不需要进行查表的操作，直接调用即可。
2. 由于子类B和子类C都是继承于基类A，因此他们都会存在一个虚指针用于指向虚函数表。注意，假如子类B和子类C中不存在虚函数，那么这时他们将共用基类A的一张虚函数表，在B和C中用虚指针指向该虚函数表即可。但是，上面的代码设计时子类B和子类C中都有一个虚函数 vfunc1，因此他们就需要各自产生一张虚函数表，并用各自的虚指针指向该表。由于子类B和子类C都对 vfunc1 作了重载，因此他们有三种不同的实现方式，函数地址也不尽相同，在使用的时候需要从各自类的虚函数表中去查找对应的 vfunc1 地址。
3. 对于虚函数 vfunc2，两个子类都没有进行重载操作，所以基类A、子类B和子类C将共用一个 vfunc2，该虚函数的地址会分别保存在三个类的虚函数表中，但他们的地址是相同的。
4. 从上图可以发现，在类对象的头部存放着一个虚指针，该虚指针指向了各自类所维护的虚函数表，再通过查找虚函数表中的地址来找到对应的虚函数。
5. 对于类中的数据而言，子类中都会包含父类的信息。如上例中的子类C，它自己拥有一个变量 m_data1，似乎是和基类中的 m_data1 重名了，但其实他们并不存在联系，从存放的位置便可知晓。

关于动态绑定

在设计了以上三个类之后，我们就要开始对它们进行使用。
int main() 
{

    B b;
    b.vfunc1();

    A a = (A)b;
    a.vfunc1();
}
 假如在程序中分别创建两个对象 a 和 b，a的创建是通过将b强制转化为类A得来的。对于 b.vfunc1() 的调用，应该没有太的疑问，它所调用的就是类B中的 vfunc1。而对于 a.vfunc1() 的调用，它虽然是强制转化后的结果，但并不能改变它是一个类A对象的事实，因此这里调用的便是类A中的 vfunc1，也就是上图中显示绿色的函数。
int main() 
{

    A* pa = new B;
    pa->vfunc1();

    B b;
    pa = &b;
    pa->vfunc1();
}
 将程序改写成以上内容，pa 是一个类A的指针，但它指向的是一个类B的对象。在使用pa调用 vfunc1 的时候，程序发现pa是一个指针，并且现在正在调用一个虚函数叫做 vfunc1，这时通过 pa->vptr 这个虚指针到类B的虚函数中（上图的B vtbl）找对应的虚函数地址，找到该地址以后，就用相应的虚函数来进行调用，也就是调用上图所示的 B::vfunc1()。
pa是类A的指针，为什么查找的是类B的虚函数表？
只要某一个类X包含虚函数，无论是它的父类或者它本身拥有，那么这个类的对象都会包含一个虚指针vptr，至于vptr要指向哪张表，取决于类X它本身是否含有虚函数。此处，类B中存在虚函数，那么它就会拥有自己的一张虚函数表。pa指向的是一个类B的对象，因此 p-vptr 指代的是类B中虚指针，所以它查找的是类B的虚函数表

如何从虚函数表中查找到 vfunc1 的地址？
虚函数表中的内容是在编译的时候确定的，通过以下方式进行查找 (* p->vptr[n] )(p) 或者 (* (p->vptr)[n] )(p)，它的解读是：通过类对象指针p找到虚指针vptr，再查找到虚函数表中的第n个内容，并将他作为函数指针进行调用，调用时的入参是p(式子中的第二个p)，而这个p就是隐藏的this指针，这里的n也是在编译的时候确定的。
int main()
{

    A a;
    B b;

    A* p1 = &a;
    p1->vfunc1();

    A* p2 = &b;
    p2->vfunc1();
}
 再将程序修改成以上内容，对于 p2->vfunc1() 的调用和上文所述一致，它调用的是 B::vfunc1 函数。而对于 p1->vfunc1() 的调用，同样通过上面的方法可知， p1->vptr 它所指向的是类A的虚函数表，因此它调用的是 A::vfunc1 函数。
 通过以上内容，我们可以知道在使用基类指针调用虚函数的时候，它能够根据所指的类对象的不同来正确调用虚函数。而这些能够正常工作，得益于虚指针和虚函数表的引入，使得在程序运行期间能够动态调用函数。
动态绑定有以下三项条件要符合：
1.    使用指针进行调用
2.    指针属于up-cast后的
3.    调用的是虚函数
与动态绑定相对应的是静态绑定，它属于编译的时候就确定下来的，如上文的非虚函数，他们是类对象直接可调用的，而不需要任何查表操作，因此调用的速度也快于虚函数。
 

今天的文章虚函数及虚函数表_一个类有几个虚函数表分享到此就结束了，感谢您的阅读。