目前最经典的关于虚函数的解释整理

自己也曾经被这些东西所困惑过，看见这篇文章写的不错，转载了过来，希望能给同样的迷茫中的人一点线索，仅供参考！（唯一不足之处就是应该把内存示意图贴出来就好多了，有时间我补上）

[1]C++ 对象模型基础

一个类中可以包含静态数据成员、静态成员函数、非静态成员函数和非静态数据成员以及虚函数。其中，前三者（静态数据成员、静态成员函数、非静态成员函数）都并没有被放到对象的布局中，可以从以下两段代码得到验证：

view plaincopy to clipboardprint?
#include  <iostream>  
using namespace std;  
   
class Base {  
};  
   
int main(){  
     Base a;  
     cout << sizeof (a) << endl;// 输出1  
     return 0;  
}  
#include  <iostream>
using namespace std;
 
class Base {
};
 
int main(){
     Base a;
     cout << sizeof (a) << endl;// 输出1
     return 0;
}

上述的 Base 类是一个空类，占据了一个字节的内存空间，这是为了保证每个类实例化后都拥有独一无二的内存空间。接着我们往 Base 类中添加静态数据成员、静态成员函数和非静态成员函数：

view plaincopy to clipboardprint?
#include  <iostream>  
using namespace std;  
   
class Base {  
public :  
     Base(){}  
     ~Base(){}  
     static int v1;  
     static void f1(){}  
     void f2(){}  
};  
   
int main(){  
     Base a;  
     cout << sizeof (a) << endl;// 仍然输出1  
     return 0;  
}  
#include  <iostream>
using namespace std;
 
class Base {
public :
     Base(){}
     ~Base(){}
     static int v1;
     static void f1(){}
     void f2(){}
};
 
int main(){
     Base a;
     cout << sizeof (a) << endl;// 仍然输出1
     return 0;
}

在经过内容填充后， Base 类的实例 a 仍然仅占据 1 个字节的内存空间，与空类无异，这说明了静态数据成员、静态成员函数和非静态成员函数并未被放在对象的内存布局当中 。

接下来往类中添加非静态数据成员：

view plaincopy to clipboardprint?
#include  <iostream>  
using namespace std;  
   
class Base {  
public :  
     int a;  
     int b;  
};  
   
int main(){  
     Base a;  
     cout << sizeof (a) << endl;// 输出8  
     cout << hex << &a << endl;// 输出0012F 3CC  
     cout << hex << &a.a << endl;// 输出0012F 3CC  
     cout << hex << &a.b << endl;// 输出0012F 3D0  
     return 0;  
}  
#include  <iostream>
using namespace std;
 
class Base {
public :
     int a;
     int b;
};
 
int main(){
     Base a;
     cout << sizeof (a) << endl;// 输出8
     cout << hex << &a << endl;// 输出0012F 3CC
     cout << hex << &a.a << endl;// 输出0012F 3CC
     cout << hex << &a.b << endl;// 输出0012F 3D0
     return 0;
}

从上面的代码可以看出：一，非静态数据成员是会被放到对象的内存布局中；二，数据成员是根据声明顺序有序地在内存中进行分布的；三，在没有虚函数的情况下对象所占据的内存大小就是数据成员所占据的空间之和。布局如下图：

a
 
b
 

那么如果添加了虚函数以后呢？先看一段代码：

view plaincopy to clipboardprint?
#include  <iostream>  
using namespace std;  
   
class Base {  
public :  
     int a;  
     int b;  
     void doit(){ }  
protected :  
     virtual void vf(){ cout << "hi" << endl; }  
     virtual void vf_(){}  
};  
   
int main(){  
     Base a;  
     cout << sizeof (a) << endl;// 输出12  
     cout << hex << &a << endl;// 输出0012F 3C 8  
     cout << hex << &a.a << endl;// 输出0012F 3CC  
     cout << hex << &a.b << endl;// 输出0012F 3D0  
     return 0;  
}  
#include  <iostream>
using namespace std;
 
class Base {
public :
     int a;
     int b;
     void doit(){ }
protected :
     virtual void vf(){ cout << "hi" << endl; }
     virtual void vf_(){}
};
 
int main(){
     Base a;
     cout << sizeof (a) << endl;// 输出12
     cout << hex << &a << endl;// 输出0012F 3C 8
     cout << hex << &a.a << endl;// 输出0012F 3CC
     cout << hex << &a.b << endl;// 输出0012F 3D0
     return 0;
}

Base 基类中有两个虚函数，这两个虚函数（如果只有一个虚函数情况也一样）出现后使得对象 a 的大小变为 12 ，相较于没有虚函数的情况多了 4 个字节，即 32 位，相当于一个指针所占的内存大小。

包含虚函数的类的对象实例中会在内存布局中多添加了一个 vptr 指针，这个指针指向（不仅）存放虚函数地址的虚表 vtbl ，所以不管类中只有一个虚函数或者有多个，在对象实例中只会多出一个指针需要的空间大小，即 4 个字节。

此外， vptr 通常存放在对象内存布局中的起始处 。从上一段代码输出的地址就可以看出成员变量 a 占据 0012F 3CC 到 0012F 3CF 的空间，成员变量 b 占据 0012F 3D0 到 0012F 3D3 的空间，而对象首址 0012F 3C 8 到 0012F 3CB 则是用来存放 vptr 的。总计 12 字节，布局如下图：

vptr
 
a
 
b
 

 

[2] 继承关系下的模型和指针类型

在单继承的情况下，对象实例的内存布局中，基类部分位于子类部分前；而对于多继承，不同的基类部分会按照继承声明顺序在内存中陆续分布。如下是一个代码示例：

view plaincopy to clipboardprint?
#include  <iostream>  
using namespace std;  
   
class Base {  
public :  
     void doit(){ vf(); }  
     int bv;  
protected :  
     virtual void vf(){ cout << "Base" << endl; }  
};  
   
class Base1 {  
public :  
     void doit1(){ vf1(); }  
     int b1v;  
protected :  
     virtual void vf1(){ cout << "Base1" << endl; }  
};  
   
class Demo : public Base, public Base1 {  
protected :  
     void vf(){ cout << "Demo" << endl; }  
     virtual void vf1(){ cout << "Demo1" << endl; }  
     virtual void vf2(){}  
public :  
     int dv;  
};  
   
int main(){  
     Demo d;  
     cout << sizeof (d) << endl;// 输出  
     cout << hex << &d << endl;// 输出F3B8  
     cout << hex << &d.bv << endl;// 输出F3BC  
     cout << hex << &d.b1v << endl;// 输出F3C4  
     cout << hex << &d.dv << endl;// 输出F3C8  
     Base *p = &d;  
     p->doit();// 输出Demo ，即执行子类重写的虚函数  
     cout << hex << p << endl;// 输出F3B8  
     Base1 *p1 = &d;  
     cout << hex << p1 << endl;// 输出F3C0  
     return 0;  
}  
#include  <iostream>
using namespace std;
 
class Base {
public :
     void doit(){ vf(); }
     int bv;
protected :
     virtual void vf(){ cout << "Base" << endl; }
};
 
class Base1 {
public :
     void doit1(){ vf1(); }
     int b1v;
protected :
     virtual void vf1(){ cout << "Base1" << endl; }
};
 
class Demo : public Base, public Base1 {
protected :
     void vf(){ cout << "Demo" << endl; }
     virtual void vf1(){ cout << "Demo1" << endl; }
     virtual void vf2(){}
public :
     int dv;
};
 
int main(){
     Demo d;
     cout << sizeof (d) << endl;// 输出
     cout << hex << &d << endl;// 输出F3B8
     cout << hex << &d.bv << endl;// 输出F3BC
     cout << hex << &d.b1v << endl;// 输出F3C4
     cout << hex << &d.dv << endl;// 输出F3C8
     Base *p = &d;
     p->doit();// 输出Demo ，即执行子类重写的虚函数
     cout << hex << p << endl;// 输出F3B8
     Base1 *p1 = &d;
     cout << hex << p1 << endl;// 输出F3C0
     return 0;
}

Base 基类因为有一个 vptr 和一个数据成员 bv ，所以占据了 8 个字节； Base1 基类同样有 vptr 和数据成员 b1v ，所以也占据了 8 个字节；而子类 Demo 继承了 Base 和 Base1 ，又新增了一个数据成员 dv ，所以总共占据了 20 个字节的空间。

对象 d 占据了从 0012F 3B8 到 0012F 3CB 的 20 个字节内存空间，其中 Base 基类的部分位于 0012F 3B8 到 0012F 3BF 的 8 个字节， Base1 基类部分紧随其后，占据 0012F 3C 0 到 0012F 3C 7 的内存空间，最后是子类本身的数据成员 dv 。布局如下图所示：

vptr_Base
 
bv
 
vptr_Base1
 
b1v
 
dv
 

注意到指针 p 和 p1 的声明和赋值，以及所指向的首址。指针 p 的类型是 Base * ，它指向了对象 d 中的 Base 基类部分；指针 p1 的类型是 Base1 * ，它指向了对象 d 中的 Base1 部分。指针类型的作用是给予编译器信息，表明指针指向的对象类型（包含首址以及大小等信息），因为子类中含有基类部分，所以基类指针可以指向子类，更实质地讲是指向子类中的基类部分。

既然 Base * 类型的指针指向的是内存中 Base 基类的部分，那么为什么运行下述语句会执行子类中的虚函数呢？

view plaincopy to clipboardprint?
Base *p = &d;  
p->doit();// 输出Demo ，即执行子类重写的虚函数  
     Base *p = &d;
     p->doit();// 输出Demo ，即执行子类重写的虚函数

首先我们确定指针 p 能访问的只有 vptr_Base 和 bv 这两个成员，其中 vptr_Base 指向一个虚表，虚表中存放着类型信息和虚函数的地址。这里不妨认为 vptr_Base[1] 存放着虚函数 vf 的地址。

在编译阶段可以针对虚函数机制做的工作有：一，确定虚表的地址，即 vptr 的指向；二，确定虚表的大小和内容；三，针对不同虚函数的调用，转换为对虚表不同表项的索引。在确定虚表的内容时，如果子类重写了基类的虚函数，那么虚表中对应的表项会被修改指向子类重新实现的函数地址；否则的话，仍旧指向基类中定义的虚函数。

在上述代码中，由于 Demo 类中重写了虚函数 vf ，所以 vptr_Base[1] 指向了子类中的虚函数实体，而非 Base 中定义的 vf 。

经过编译后，我们知道对 vf 函数的调用相当于调用 vptr_Base[1] 所指向的函数，但是在这个阶段无法知道调用的虚函数到底是基类定义的还是子类中重写的，因为 Base * 类型的指针可以指向一个 Base 类型对象，也可以指向子类 Demo 中的 Base 基类部分 。因此，只有在执行期才可以知道 vptr_Base[1] 到底指向哪一个 vf 函数实体。

 

[3] 编码层次的虚函数

如果基类希望某个成员函数由子类重定义，那么应该将其声明为 virtual 类型。虚函数是动态绑定的基础，（只有）通过基类类型的指针或引用进行虚函数的调用才可以触发动态绑定，这体现了多态这一面向对象的关键思想。可以看出，基类类型的指针或引用既可以指向基类类型对象也可以指向子类类型对象的特性是动态绑定的关键。

通过虚函数可以实现运行时多态，这有利于公共接口的实现。即在继承体系中处于不同层次的类使用同一接口，但运行时会根据具体对象类型的差异而采取不同的策略。这种风格在良好的软件体系结构可以经常发现，比如 Qt 。

在实际编码设计过程中需要注意以下几点：

1、  要发生动态绑定，实现运行时的多态，需要通过基类的指针或者引用调用虚函数，这样在运行时才会根据指针或引用所指向的对象的实际类型调用相应的目标函数。

2、  关键字 virtual 只能在类内部的成员声明中出现，而不能出现在类定义体外部。

3、  一经声明为虚函数，则一直是虚函数；子类可以不用显示声明 virtual ，但虚函数的特性不会改变。

4、  子类中虚函数的声明必须和基类的定义方式匹配，除了基类中虚函数返回对基类类型的指针或引用，在这种情况下，子类中的虚函数可以返回基类函数所返回类型的子类的指针或引用。

5、  子类中虚函数调用基类的虚函数必须使用显示作用域声明，或者会递归调用自身。

6、  纯虚函数仅作为抽象接口以供覆盖，包含纯虚函数的类是抽象基类，不能被实例化。

 

 

 

 

 

 

下面是另外一篇文章，正好有上一篇文章没有的虚表结构图，虽然例子不同，当时殊途同归！（再次转载过来，我也就不用自己动手画图了，哈哈哈……两篇文章对比阅读，相信能有豁然开朗之感！！！在这里感谢原作者）

 

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

 

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，表示是最后一个虚函数表。

 

 

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

 

一般继承（无虚函数覆盖）

 

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

 

 

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

 

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

 

我们可以看到下面几点：

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

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

 

 

 

 

 

一般继承（有虚函数覆盖）

 

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

 

 

 

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

 

 

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

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

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

 

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

 

       Base *b = new Derive();

 

       b->f();

 

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

 

 

 

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

 

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

 

 

 

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

 

我们可以看到：

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()

 

 

安全性

 

通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

 

一、通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

 

       Base1 *b1 = new Derive();

       b1->f1();  //编译出错

 

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。

 

二、访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

 

如：

 

class Base {

    private:

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

 

};

 

class Derive : public Base{

 

};

 

typedef void(*Fun)(void);

 

void main() {

    Derive d;

    Fun  pFun = (Fun)*((int*)*(int*)(&d)+0);

    pFun();

}

 

相信经过上面的两篇文章的论述，您对虚表的轮廓是不是更加清晰了些呢？再次感谢原作者！

摘自：http://blog.sina.com.cn/s/blog_4950d6160100urvd.html