C++虚函数与虚函数表

多态性可分为两类：静态多态和动态多态。函数重载和运算符重载实现的多态属于静态多态，动态多态性是通过虚函数实现的。

每个含有虚函数的类有一张虚函数表(vtbl)，表中每一项是一个虚函数的地址， 也就是说，虚函数表的每一项是一个虚函数的指针。

没有虚函数的C++类，是不会有虚函数表的。

两张图：

 

 

---

简单例子：

 

 1 #include <iostream>

 2 #include <windows.h>

 3 

 4 using namespace std;

 5 

 6 class base

 7 {

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

 9     virtual void g(){cout<<"base::g"<<endl;};

10     virtual void h(){cout<<"base::h"<<endl;};

11 };

12 

13 typedef void (*pfun)();

14 

15 void main()

16 {

17     DWORD w=0x4011e0; //虚函数表第一项的内容，也就是第一个虚函数的地址

18 

19     pfun fun=NULL;

20     base b;

21     base *pbase=&b;

22 

23     fun=(pfun)w;

24     fun();    //调用第一个虚函数

25 }

查看对象b在内存中：

查看虚函数表：

 

 虚函数表的指针4个字节大小（vptr），存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

 

虚函数表的结束标志在不同的编译器下是不同的。在VC6.0下，这个值是NULL，如图：

 

 

---

另一个例子：

 

 1 #include <iostream>

 2 

 3 using namespace std;

 4 

 5 class base

 6 {

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

 8     virtual void g(){cout<<"base::g"<<endl;};

 9     virtual void h(){cout<<"base::h"<<endl;};

10 };

11 

12 class Derive : public base

13 {

14     

15 public:

16     Derive(){};

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

18     virtual void g() { cout << "Derive::g" << endl; }

19     

20 };

21 

22 typedef void(*pfun)();

23 

24 void main()

25 {

26     pfun fun=NULL;

27     Derive d;

28     base *p=&d;

29 

30     fun=(pfun)**((int**)p);

31     fun();    //调用第一个虚函数

32 

33     fun=(pfun)*(*((int**)p)+2);

34     fun();    //调用第三个函数

35 

36 }

 

查看对象d在内存中：

 

---

多重继承：

   有几个父类，就有几个vtab和vptr

 

 

 

代码：

  1 #include <iostream>

  2  

  3 using namespace std;

  4  

  5 class Base1 {

  6  

  7 public:

  8  

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

 10  

 11             virtual void g() { cout << "Base1::g" << endl; }

 12  

 13             virtual void h() { cout << "Base1::h" << endl; }

 14  

 15  

 16  

 17 };

 18  

 19 class Base2 {

 20  

 21 public:

 22  

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

 24  

 25             virtual void g() { cout << "Base2::g" << endl; }

 26  

 27             virtual void h() { cout << "Base2::h" << endl; }

 28  

 29 };

 30  

 31  

 32 class Base3 {

 33  

 34 public:

 35  

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

 37  

 38             virtual void g() { cout << "Base3::g" << endl; }

 39  

 40             virtual void h() { cout << "Base3::h" << endl; }

 41  

 42 };

 43  

 44  

 45 class Derive : public Base1, public Base2, public Base3 {

 46  

 47 public:

 48  

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

 50  

 51             virtual void g1() { cout << "Derive::g1" << endl; }

 52  

 53 };

 54  

 55  

 56 typedef void(*Fun)(void);

 57  

 58 int main() 

 59 

 60 {

 61  

 62             Fun pFun = NULL;

 63  

 64             Derive d;

 65  

 66             int** pVtab = (int**)&d;

 67  

 68             //Base1's vtable

 69  

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

 71  

 72             pFun = (Fun)pVtab[0][0];

 73  

 74             pFun();

 75  

 76 

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

 78  

 79             pFun = (Fun)pVtab[0][1];

 80  

 81             pFun();

 82  

 83 

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

 85  

 86             pFun = (Fun)pVtab[0][2];

 87  

 88             pFun();

 89  

 90 

 91             //Derive's vtable

 92  

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

 94  

 95             pFun = (Fun)pVtab[0][3];

 96  

 97             pFun();

 98  

 99  

100             //The tail of the vtable

101  

102             pFun = (Fun)pVtab[0][4];

103  

104             cout<<pFun<<endl;

105  

106  

107             //Base2's vtable

108  

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

110  

111             pFun = (Fun)pVtab[1][0];

112  

113             pFun();

114  

115  

116             //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

117  

118             pFun = (Fun)pVtab[1][1];

119  

120             pFun();

121  

122 

123             pFun = (Fun)pVtab[1][2];

124  

125             pFun(); 

126 

127  

128             //The tail of the vtable

129  

130             pFun = (Fun)pVtab[1][3];

131  

132             cout<<pFun<<endl;

133  

134  

135             //Base3's vtable

136  

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

138  

139             pFun = (Fun)pVtab[2][0];

140  

141             pFun();

142  

143  

144             //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

145  

146             pFun = (Fun)pVtab[2][1];

147  

148             pFun();

149  

150  

151             pFun = (Fun)pVtab[2][2];

152  

153             pFun(); 

154 

155  

156             //The tail of the vtable

157  

158             pFun = (Fun)pVtab[2][3];

159  

160             cout<<pFun<<endl;

161  

162  

163             cout<<sizeof(d)<<endl;

164 

165             return 0;

166  

167 }