C++中虚函数功能介绍_C/C++_编程开发_程序员俱乐部

西安达内培训(http://www.xatarena.net)讲师表示，C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。C++有一个编译选项：/d1 reportAllClassLayout，用来输出所有的类型信息，比较有趣。如下图，在工程，属性，编译的命令行中，增加一个“其他选项”，填写/d1 reportAllClassLayout即可。在编译类时，就会生成类的内存结构图。包括虚函数指针表。


首先编写一个普通的类：

class Base
{
public:
    Base(){}
    ~Base(){}

    void f0() {}
    void f1() {}
    void f2() {}
    void f3() {}

private:
    int a;
};
编译后，生成的类型信息为：

class Base    size(4):
    +---
0  | a
    +---

可以看到这个类的对象的实际大小仅仅是4字节的int变量所占用的的大小。在《More Effective C++》中讲到过，虚函数会生成虚函数指针表。所有带有虚函数的类型的对象，都会有一个额外的虚函数指针索引表。这个索引表对于编程者是不可见的，但是运行时，这个索引非常重要，是实现动态绑定的关键。

从C语言到C++的同学可能有一个习惯，直接使用memset对结构体对象进行初始化，而不是使用大括号加逗号的方式给每一个成员逐一赋值。在C++里面，一般不会直接对对象进行memset，也不会使用大括号加逗号的方式，而是使用各种构造函数对每一个成员进行赋值。这不仅仅是一个习惯的问题，如果使用memset对C++里面的对象进行初始化，当对象的类型中含有虚函数时，会使得程序运行异常。因为在赋值过程中，将虚函数表也赋值了，这样虚函数指针被指向了未知内存。当调用虚函数时，就会使得程序异常。

特别的，一般我们会把类的析构函数声明为虚函数，如果在使用该类的对象过程中使用了memset，那么程序异常的时候往往发生在对象析构的时候，对象析构的过程是由编译器生成的代码来完成的，不可见，这样，栈上面申请的对象，在退栈的时候自动析构，因此调试代码会发现，是在一个函数调用返回的地方发生了core dump，检查代码又找不到原因，其实这里就是虚函数表被重新赋值了导致的。

将上述类中的析构函数修改为virtual ~Base() {}后，得到的类型的内存占用信息为：

class Base size(8):
    +---
0  | {vfptr}
4  | a
    +---

Base::$vftable@:
    | &Base_meta
    |  0
0  | &Base::{dtor}

Base::{dtor} this adjustor: 0
Base::__delDtor this adjustor: 0
Base::__vecDelDtor this adjustor: 0
从上图可以看出，Base类中多出了4个字节的函数指针表，vfptr放在对象的头部，开始的4个字节即是函数指针。

再来看一下多态又是怎么借助于虚函数表实现的。

class Base
{
public:
    Base(){}
    virtual ~Base(){}

    virtual void f1() {}
    void f2() {}
    void f3() {}

private:
    int a;
};

class Sub : public Base
{
public:
    Sub() {}
    virtual ~Sub() {}

    virtual void f1() {} // 子类对f1提供新的实现

    virtual void g1() {}
    virtual void g2() {}
    virtual void g3() {}
   
private:
    int int_in_b2;
};

class Sub2 : public Sub
{
public:
    Sub2() {}
    virtual ~Sub2() {}

    virtual void h1() {}
    virtual void h2() {}
    virtual void h3() {}

    virtual void f1() {} // 子类对f1提供新的实现
    virtual void f2() {} // 子类对覆盖Base中的f1的实现
private:
    int int_in_b3;
};
具体的虚函数表的结构为：

class Base    size(8):
    +---
0  | {vfptr}
4  | a
    +---

Base::$vftable@:
    | &Base_meta
    |  0
0  | &Base::{dtor}
1  | &Base::f1

Base::{dtor} this adjustor: 0
Base::f1 this adjustor: 0
Base::__delDtor this adjustor: 0
Base::__vecDelDtor this adjustor: 0


class Sub    size(12):
    +---
    | +--- (base class Base)
0  | | {vfptr}
4  | | a
    | +---
8  | int_in_b2
    +---

Sub::$vftable@:
    | &Sub_meta
    |  0
0  | &Sub::{dtor}
1  | &Sub::f1
2  | &Sub::g1
3  | &Sub::g2
4  | &Sub::g3

Sub::{dtor} this adjustor: 0
Sub::f1 this adjustor: 0
Sub::g1 this adjustor: 0
Sub::g2 this adjustor: 0
Sub::g3 this adjustor: 0
Sub::__delDtor this adjustor: 0
Sub::__vecDelDtor this adjustor: 0


class Sub2    size(16):
    +---
    | +--- (base class Sub)
    | | +--- (base class Base)
0  | | | {vfptr}
4  | | | a
    | | +---
8  | | int_in_b2
    | +---
12  | int_in_b3
    +---

Sub2::$vftable@:
    | &Sub2_meta
    |  0
0  | &Sub2::{dtor}
1  | &Sub2::f1
2  | &Sub::g1
3  | &Sub::g2
4  | &Sub::g3
5  | &Sub2::h1
6  | &Sub2::h2
7  | &Sub2::h3
8  | &Sub2::f2

Sub2::{dtor} this adjustor: 0
Sub2::h1 this adjustor: 0
Sub2::h2 this adjustor: 0
Sub2::h3 this adjustor: 0
Sub2::f1 this adjustor: 0
Sub2::f2 this adjustor: 0
Sub2::__delDtor this adjustor: 0
Sub2::__vecDelDtor this adjustor: 0

在上面的类继承关系中，每一个基类的虚函数，在子类的对象中，都会产生一个虚函数指针。所有继承层次上面类的虚函数都会在子类的对象中有相应的虚函数指针。运行时，当具体的对象指针调用有多个实现的虚函数时，对象指针或者引用，根据虚函数的偏移量找到该名字的函数，然后调用即可，由于虚函数在编译时已经全部写进虚函数表中，因此运行时，并不需要明确知道具体的指针的类型，而是直接使用基类的指针即可，这也就是动态绑定的原理了。根据函数名字在虚函数表中的偏移来找虚函数，而不是根据指针类型来找虚函数。