引言
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; }
运行结果: