引言
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;
上面两种方式，都是用父类的指针指向了子类的对象。区别在于，方式一的子类对象是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;
}
上面的代码中：
- 父类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;
}
运行结果：
三、多继承的虚函数表
多继承指的是一个类同时继承多个基类，如果每个基类都有虚函数，那么对应的每个基类都有自己的虚函数表。
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;
};
上面的代码中：
- 父类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代表没有下一个虚函数表。" * "号位置在不同操作系统中实现不同，代表有下一个虚函数表。
规则：
- 子类虚函数会覆盖每一个父类的每一个同名虚函数
- 父类中没有的虚函数而子类有，填入第一个虚函数表中
- 父类中有，而子类中没有，则不覆盖。
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;
}
运行结果：
