c++ 虚函数表解析

【本文链接】

http://www.cnblogs.com/hellogiser/p/virtual-function-table.html

【分析】

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

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

　　可以将虚函数表看做一个二维数组，其中每个一维数组的首地址存储在对象的实例之中。

　　来看个例子，通过实例得到虚函数表地址，进而访问虚函数。

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

图解如下

在上面这个图中，虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“/0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。

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

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

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

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

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

我们可以看到下面几点：

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

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

代码验证如下

 C++ Code 

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

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

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

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

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

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

代码验证如下

 C++ Code 

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

 C++ Code 

1
2

Base *b = new Derived();
b->f();

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

代码验证如下

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

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

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

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

我们可以看到：

1）每个父类都有自己的虚表，虚表的顺序与继承顺序有关。

 C++ Code 

class Derived : public Base1, public Base2, public Base3

虚表的顺序依次为Base1,Base2,Base3

 C++ Code 

class Derived : public Base3, public Base2, public Base1

虚表的顺序依次为Base3,Base2,Base1

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

代码验证如下

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/*
version: 1.0
author: hellogiser
blog: http://www.cnblogs.com/hellogiser
date: 2014/9/29
*/

#include "stdafx.h"
#include <iostream>
using namespace std;

class Base1
{
public:
    Base1()
    {
    }

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

class Base2
{
public:
    Base2()
    {
    }

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

class Base3
{
public:
    Base3()
    {
    }

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

class Derived: public Base1, public Base2, public Base3
{
    virtual void f1()
    {
        cout << "Derived::f1" << endl;
    }
    virtual void g1()
    {
        cout << "Derived::g1" << endl;
    }
};

typedef void(*Fun)(void);

void test()
{
    Derived obj;
    Fun pFun;
    int **pVtab = (int **)(&obj);

    // base1
    pFun = (Fun)pVtab[0][0];
    pFun();

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

    pFun = (Fun)pVtab[0][2];
    pFun();
    //====================================
    // derived
    pFun = (Fun)pVtab[0][3];
    pFun();
    pFun = (Fun)pVtab[0][4];
    pFun();
    //====================================

    // base2
    pFun = (Fun)pVtab[1][0];
    pFun();

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

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

    // base3
    pFun = (Fun)pVtab[2][0];
    pFun();

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

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

int main()
{
    test();
    return 0;
}
/*
Base1::f
Base1::g
Base1::h
Derived::f
Derived::g1
Base2::f
Base2::g
Base2::h
Base3::f
Base3::g
Base3::h
*/

更改一下继承为Base3,Base2,Base1验证结果如下

 C++ Code 

/*
version: 1.0
author: hellogiser
blog: http://www.cnblogs.com/hellogiser
date: 2014/9/29
*/

#include "stdafx.h"
#include <iostream>
using namespace std;

class Base1
{
public:
    Base1()
    {
    }

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

class Base2
{
public:
    Base2()
    {
    }

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

class Base3
{
public:
    Base3()
    {
    }

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

class Derived: public Base3, public Base2, public Base1
{
    virtual void f1()
    {
        cout << "Derived::f1" << endl;
    }
    virtual void g1()
    {
        cout << "Derived::g1" << endl;
    }
};

typedef void(*Fun)(void);

void test()
{
    Derived obj;
    Fun pFun;
    int **pVtab = (int **)(&obj);

    // base3
    pFun = (Fun)pVtab[0][0];
    pFun();

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

    pFun = (Fun)pVtab[0][2];
    pFun();
    //====================================
    // derived
    pFun = (Fun)pVtab[0][3];
    pFun();
    pFun = (Fun)pVtab[0][4];
    pFun();
    //====================================

    // base2
    pFun = (Fun)pVtab[1][0];
    pFun();

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

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

    // base1
    pFun = (Fun)pVtab[2][0];
    pFun();

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

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

int main()
{
    test();
    return 0;
}
/*
Base3::f
Base3::g
Base3::h
Derived::f1
Derived::g1
Base2::f
Base2::g
Base2::h
Base1::f
Base1::g
Base1::h
*/

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

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

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

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

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11

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

代码验证如下

 C++ Code 

/*
version: 1.0
author: hellogiser
blog: http://www.cnblogs.com/hellogiser
date: 2014/9/29
*/

#include "stdafx.h"
#include <iostream>
using namespace std;

class Base1
{
public:
    Base1()
    {
    }

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

class Base2
{
public:
    Base2()
    {
    }

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

class Base3
{
public:
    Base3()
    {
    }

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

class Derived: public Base1, public Base2, public Base3
{
    virtual void f()
    {
        cout << "Derived::f" << endl;
    }
    virtual void g1()
    {
        cout << "Derived::g1" << endl;
    }
};

typedef void(*Fun)(void);

void test()
{
    Derived obj;
    Fun pFun;
    int **pVtab = (int **)(&obj);

    // base1
    pFun = (Fun)pVtab[0][0];
    pFun();

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

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

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

    // base2
    pFun = (Fun)pVtab[1][0];
    pFun();

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

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

    // base3
    pFun = (Fun)pVtab[2][0];
    pFun();

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

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

int main()
{
    test();
    return 0;
}
/*
Derived::f
Base1::g
Base1::h
Derived::g1
Derived::f
Base2::g
Base2::h
Derived::f
Base3::g
Base3::h
*/

【参考】

http://blog.csdn.net/haoel/article/details/1948051

刷新页面返回顶部

hellogiser

music lover,tvber,coder,giser.

c++ 虚函数表解析

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

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

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

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

个人学习笔记，欢迎拍砖!---by hellogiser

公告