C++多态之虚函数表详解及代码示例

引言

C++相对其他面向对象语言来说，之所以灵活、高效。很大程度的占比在于其多态技术和模板技术。C++虚函数表是支撑C++多态的重要技术，它是C++动态绑定技术的核心。

如果对多态还不了解的小伙伴，可以点这里C++多态详解基础篇。

在不考虑继承的情况下，如果一个类中有虚函数，那么这个类就有一个虚函数表，这个虚函数表在编译期间确定，这个类对象共享。而这个类所有的实例化对象中都有一个虚函数指针，这个虚函数指针就指向同一份虚函数表。

一、多态的使用及内存分布图

假设现在有个基类的class A，A中有虚函数，class B继承了A，并且B重写了A中的虚函数。那么，我们在使用多态的时候，通常会有两种方式：

// 方式一
class A* a = new class B;
// 方式二
class B b;
class A *a = &b;
1
2
3
4
5

上面两种方式，都是用父类的指针指向了子类的对象。区别在于，方式一的子类对象是new出来的，存在于堆区；方式二的子类对象则保存在栈区。

二、多重继承的虚函数表

2.1 代码示例

class A {
public:

    void func1(){ std::cout << "Class A func1" << std::endl; }
    void func2(){ std::cout << "Class A func2" << std::endl; }

    virtual void v_func1(){ std::cout << "Class A v_func1" << std::endl; }
    virtual void v_func2(){ std::cout << "Class A v_func2" << std::endl; }

private:
    int m_aMember;
};


class B : public A{
public:

    void func1(){ std::cout << "Class B func1" << std::endl; }

    virtual void v_func1(){ std::cout << "Class B v_func1" << std::endl; }

private:
    int m_bMember;   
};

class C : public B{
public:

    void func2(){ std::cout << "Class C func2" << std::endl; }

    virtual void v_func2(){ std::cout << "Class C v_func2" << std::endl; }

private:
    int m_bMember;   
};

int main(int argc, char* argv[])
{
	std::cout << "============== class B : public A ============" << std::endl;
    // class B  b;
    // class A *a = &b;
    class A* a = new class B;
    a->func1();
    a->func2();
    a->v_func1();
    a->v_func2();

    return 0;
}
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

上面的代码中：

• 父类A中，有属性m_aMember，普通函数func1() func2()，有虚函数 v_func1() v_func2()
• class B继承了A，有属性m_bMember，普通函数func1()，虚函数 v_func1()
• class C继承了B，有属性m_cMember，普通函数func2()，虚函数 v_func2()

注意，父类的虚函数表和子类的虚函数表不是同一张表，虚函数表是在编译时确定的，虚函数保存在代码段，仅有一份，属于类而不属于某个具体的实例对象。

2.2 多重继承图解

B继承于A，B的虚函数表示在A的虚函数表的基础上有所改动。改的部分就是子类B重写的父类A的虚函数v_func1()。假设此时B没有重写A任何一个虚函数，那么B类的虚函数表和类A的虚函数表的内容是相同的。

运行结果分析：

毫无疑问，对于A类型的指针来说，可见的部分只有图中红色框的部分。因为 B重写了A的虚函数v_func1()，所以在B的虚函数表会覆盖父类A的虚函数v_func1()。所以，会调用到B的虚函数v_func1()，从而实现多态。

同理，不难猜出C的逻辑结构图：C继承于B，B继承于A

int main(int argc, char* argv[])
{
    std::cout << "C -> B ->  A  " << std::endl;
    std::cout << "======= class A* a = new class C =======" << std::endl;
    class A* ac = new class C;
    ac->func1();
    ac->func2();
    ac->v_func1();
    ac->v_func2();

    std::cout << "======= class B* b = new class C =======" << std::endl;
    class B* bc = new class C;
    bc->func1();
    bc->func2();
    bc->v_func1();
    bc->v_func2();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：

三、多继承的虚函数表

多继承指的是一个类同时继承多个基类，如果每个基类都有虚函数，那么对应的每个基类都有自己的虚函数表。

class A {
public:

    void func1(){ std::cout << "Class A func1" << std::endl; }
    void func2(){ std::cout << "Class A func2" << std::endl; }

    virtual void v_func1(){ std::cout << "Class A v_func1" << std::endl; }
    virtual void v_func2(){ std::cout << "Class A v_func2" << std::endl; }

private:
    int m_aMember;
};


class B {
public:

    void func1(){ std::cout << "Class B func1" << std::endl; }

    virtual void v_func1(){ std::cout << "Class B v_func1" << std::endl; }
    virtual void v_func2(){ std::cout << "Class B v_func2" << std::endl; }
    virtual void v_func4(){ std::cout << "Class B v_func4" << std::endl; }

private:
    int m_bMember;   
};

class C : public A, public B{
public:

    void func1(){ std::cout << "Class C func1" << std::endl; }

    virtual void v_func1(){ std::cout << "Class C v_func1" << std::endl; }
    virtual void v_func2(){ std::cout << "Class C v_func2" << std::endl; }
    virtual void v_func3(){ std::cout << "Class C v_func3" << std::endl; }

private:
    int m_cMember;   
};

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

上面的代码中：

• 父类A中，有属性m_aMember，普通函数func1() func2()，有虚函数 v_func1() v_func2()
• 父类B中，有属性m_bMember，普通函数func1()，虚函数 v_func1() v_func2() v_func4()
• class C继承了A B，有属性m_cMember，普通函数func1()，虚函数 v_func1() v_func2() v_func3()

在多继承情况下，有多少个基类就有多少个虚函数表指针，前提是基类要有虚函数。
如图，虚函数表指针01指向的虚函数表是以A的虚函数表为基础的，子类C的虚函数vfunc1() vfunc2() 函数指针覆盖了虚函数表01中的虚函数指针01的位置、02位置。

当子类有多出来的虚函数时，会被添加在第一个虚函数表中，所以，子类C的 v_func3 会被添加到以A虚函数表为基础的第一个虚表中。

当有多个虚函数表时，虚函数表的结果是0代表没有下一个虚函数表。" * "号位置在不同操作系统中实现不同，代表有下一个虚函数表。

规则：

1. 子类虚函数会覆盖每一个父类的每一个同名虚函数
2. 父类中没有的虚函数而子类有，填入第一个虚函数表中
3. 父类中有，而子类中没有，则不覆盖。

int main(int argc, char* argv[])
{
    class A* a = new class C;
    a->func1();
    a->func2();
    a->v_func1();
    a->v_func2();


    class B* b = new class C;
    b->func1();
    b->v_func1();
    b->v_func2();
    b->v_func4();

    return 0;
}
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果：

文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习: