云网站开发,山西防疫最新信息,化妆品备案查询入口,西宁网站搭建企业目录
一#xff0c;多态的原理
1#xff0c;虚函数表与虚函数表指针
2#xff0c;原理调用
3#xff0c;动态绑定与静态绑定
二#xff0c;抽象类
三#xff0c;单继承和多继承关系的虚函数表
1#xff0c;单继承中的虚函数表
2#xff0c;多继承中的虚函数表 …目录
一多态的原理
1虚函数表与虚函数表指针
2原理调用
3动态绑定与静态绑定
二抽象类
三单继承和多继承关系的虚函数表
1单继承中的虚函数表
2多继承中的虚函数表
3菱形继承、菱形虚拟继承
四继承和多态常见的经典题型
1概念逻辑考察
2问答题 一多态的原理
1虚函数表与虚函数表指针 虚函数表存放虚函数指针的表简称虚表。 虚函数表指针指向虚函数表的指针。 一个含有虚函数的类中至少都有一个虚函数表指针__vfptr因为虚函数的地址要被放到虚函数表中而虚函数表本质是一个存虚函数指针的指针数组一般情况这个数组最后面放了一个nullptr。注意类似于友元函数、静态函数不能为虚函数因为它们都不属于类即都不是类的成员函数无法放到虚函数表中。 派生类的虚表生成一共有以下步骤a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后注意在vs监视窗口下可能在虚表中看不到新增的虚函数但是通过内存窗口下可以观察到。 #include iostream using namespace std; class Base { public: virtual void Fun1() { //虚函数地址存放到虚表中 cout Base::Fun1() endl; } virtual void Fun2() { //虚函数地址存放到虚表中 cout Base::Fun2() endl; } void Fun3() { //不是虚函数地址没有存放到虚表中 cout Base::Fun3() endl; } private: int _a 1; char _ch a; }; class Derive : public Base { public: virtual void Func1() { //虚函数与子类后成重写将子类的Func1覆盖 cout Derive::Func1() endl; } private: int _d 2; }; int main() { Base bb; Derive dd; return 0; } 原理图如下 我们通过以上知识来计算下基类与派生类的存储大小。观察以下代码 #include iostream using namespace std; class Base { public: virtual void Fun1() { cout Base::Fun1() endl; } virtual void Fun2() { cout Base::Fun2() endl; } void Fun3() { cout Base::Fun3() endl; } private: int _a 1; char _ch a; }; class Derive : public Base { public: virtual void Func1() { cout Derive::Func1() endl; } private: int _d 2; }; int main() { //因为有了虚函数所以这里多了虚函数表指针。虚表指针也存储在类中 cout sizeof(Base) endl; //输出12 cout sizeof(Derive) endl; //输出16 return 0; } 这里说明一下虚表指针存放的位置与平台有关有些平台可能会放到对象的最后面有些平台可能会放到对象的最前面。这里的测试是放在对象的前面且是32位机器也就是说虚表指针占用4字节空间然后这里再根据空间对齐规则计算出总空间大小。 下面我们研究下虚表存放的区域注意这里研究的不是虚表指针存放的区域即研究虚表指针指向的地址不是虚表指针本身的地址这里不要搞错。这里可以使用对比法来观察。具体做法是先输出各大区域的代表地址然后输出虚表地址(即虚表指针)通过对比观察与哪个区域代表地址相差最小的就是存储在哪块区域因为各大区域的地址相差非常大。我们先创造以下类 class Base { public: virtual void Fun1() { cout Base::Fun1() endl; } virtual void Fun2() { cout Base::Fun2() endl; } void Fun3() { cout Base::Fun3() endl; } private: int _a 1; char _ch a; }; 内部结构图如下 #include iostream using namespace std; class Base { public: virtual void Fun1() { cout Base::Fun1() endl; } virtual void Fun2() { cout Base::Fun2() endl; } void Fun3() { cout Base::Fun3() endl; } private: int _a 1; char _ch a; }; int main() { Base bb; //创造熟为认知的四大区域的代表 int a 0; int* b new int; static int c 1; const char* d a; fprintf(stdout, 栈区: %p\n, a); fprintf(stdout, 堆区: %p\n, b); fprintf(stdout, 静态区(数据段): %p\n, c); fprintf(stdout, 常量区(代码段): %p\n, d); //因为在32位下内存中一个地址占用四个字节所以这里解引用需解出bb对象开头的前四字节内容。这里可转换成int*一次性可解引用出4个字节 Base* pb bb; fprintf(stdout, 虚表存放区域: %p\n, *(int*)pb); //地址与常量区代表地址最相近即虚表存放在常量区中 return 0; } 2原理调用 虚函数的重写在某种意义上来讲也叫做覆盖。我们通常所说的重写是语法层上的概念而覆盖是原理层上的概念这也就是父类虚函数覆盖子类虚函数。 这里要说明一下虚表是在编译的时候就已经生成但虚表指针是在构造函数中初始化通常在初始化列表的最开始阶段。若平台将虚表指针放在最后面也不排除在初始化列表的最后才初始化。但一般情况下平台都将虚表指针放在最前面这里可通过监视窗口可观察到。 多态以后的函数调用不是在编译时确定的是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时是确认好的。 多态调用的本质是在运行时去虚函数表中找函数的地址进行调用因此调用前必须先确定虚表以及虚表指针虚表指针又是在构造函数阶段才生成多态调用的机制也是在构造函数之后才生效也就是说多态的调用是在构造函数之后才调用所以指向父类调用的是父类的虚函数指向子类调用的是子类的虚函数。普通调用的本质是系统直接通过调用者类型确定函数地址也就是在某一具体空间作用域中去查找。对于多态调用而言即便实例化出多个对象它们的虚表指针以及存放的虚函数地址都是一样的如下
测试一 #include iostream using namespace std; class A { public: virtual void func(int val 1) { std::cout A- val std::endl; } virtual void test() { func(); } A() { func(); } }; class B : public A { public: B() { func(); } virtual void func(int val 0) { std::cout B- val std::endl; } }; int main(int argc, char* argv[]) { A* p new B; p-test(); //以次输出A-1 B-0 B-1 return 0; } 首先当new B时先调用父类A的构造函数执行func时由于此时还处于对象构造阶段多态机制还没有生效所以此时执行的func函数为父类的func函数输出A-1。构造完父类后执行子类构造函数又要调用func同理执行子类的func输出B-0。当构造函数结束后再次调用多态机制生成后面就正常调用。
测试二 #include iostream using namespace std; class A { public: A() : m_iVal(0) { test(); } virtual void func() { std::cout m_iVal ; } void test() { func(); } public: int m_iVal; }; class B : public A { public: B() { test(); } virtual void func() { m_iVal; std::cout m_iVal ; } }; int main() { //以下输出0 0 1 A a; B b; //当调用完A的构造后A中的基表就确定了。 //子类B的虚表是拷贝父类的虚表内容也就是说子类调用完构造函数之后多态机制就已经生成 return 0; } 测试三 #include iostream using namespace std; class Base { public: virtual void Fun1() { cout Base::Fun1() endl; } virtual void Fun2() { cout Base::Fun2() endl; } void Fun3() { cout Base::Fun3() endl; } private: int _a 1; char _ch a; }; class Derive : public Base { public: virtual void Func1() { cout Derive::Func1() endl; } private: int _d 2; }; int main() { Base bb1; Base bb2; Base bb3; Derive dd1; Derive dd2; Derive dd3; return 0; } 内部结构图 3动态绑定与静态绑定 1静态绑定又称为前期绑定(早绑定)在程序编译期间确定了程序的行为也称为静态多态比如函数重载 2动态绑定又称后期绑定(晚绑定)是在程序运行期间根据具体拿到的类型并确定程序的具体行为调用具体的函数也称为动态多态。 以上两个概念只需了解即可。 二抽象类 在虚函数的后面写上 0 则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类也叫接口 类抽象类不能实例化出对象。派生类继承后也不能实例化出对象只有重写纯虚函数派生 类才能实例化出对象。也就是说纯虚函数规范了派生类必须重写。 #include iostream using namespace std; class Car //抽象类 { public: virtual void Drive() 0 { //纯虚函数 cout Car endl; }; }; class Benz : public Car { public: virtual void Drive() //重写抽象类的纯虚函数可以被实例化 { cout Benz endl; } }; class BMW : public Car { }; int main() { //重写纯虚函数实例化成功 Benz a; a.Drive(); //没有重写纯虚函数实例化报错 BMW b; return 0; } 最后说明一下接口继承和实现继承。普通函数的继承是一种实现继承派生类继承了基类函数可以使用函数继承的是函数的实现。虚函数的继承是一种接口继承派生类继承的是基类虚函数的接口目的是为了重写达成多态继承的是接口。所以如果不实现多态不要把函数定义成虚函数。 三单继承和多继承关系的虚函数表
1单继承中的虚函数表 之前说过在vs监视窗口下可能在虚表中看不到新增的虚函数这里我们实践下如下 class Base { public: virtual void func1() { cout Base::func1 endl; } virtual void func2() { cout Base::func2 endl; } private: int a; }; class Derive : public Base { public: virtual void func1() { cout Derive::func1 endl; } virtual void func3() { cout Derive::func3 endl; } virtual void func4() { cout Derive::func4 endl; } private: int b; }; 观察上图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数也可以认为是它的一个小bug。那么我们如何查看d的虚表呢下面我们使用代码打印出虚表中的函数。 #include iostream using namespace std; class Base { public: virtual void func1() { cout Base::func1 endl; } virtual void func2() { cout Base::func2 endl; } private: int a; }; class Derive : public Base { public: virtual void func1() { cout Derive::func1 endl; } virtual void func3() { cout Derive::func3 endl; } virtual void func4() { cout Derive::func4 endl; } private: int b; }; typedef void(*VFPTR) (); //声明函数指针VFPTR void PrintVTable(VFPTR vTable[]) { for (int i 0; vTable[i] ! nullptr; i) { //vs下的虚表最后一个存储单元为nullptr cout vTable[ i ]: vTable[i] endl; } cout endl; } int main() { Base b; Derive d; VFPTR* vTableb (VFPTR*)(*(int*)b); //用函数二级指针来表示函数指针数组 PrintVTable(vTableb); VFPTR* vTabled (VFPTR*)(*(int*)d); //与上同理 PrintVTable(vTabled); return 0; } 这里需说明的是这个打印虚表的代码经常会崩溃因为编译器有时对虚表的处理不干净虚表最后面没有放nullptr导致越界这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案再编译就好了。 2多继承中的虚函数表 在多继承中要谨记派生类的虚表内容是将基类中的虚表内容拷贝一份到派生类虚表中。从这里不难发现在多继承中派生类不止有一个虚表即继承多少个类就有多少个虚表。当派生类的虚函数往虚表中添加地址时会往第一个继承基类虚表中添加。当派生类对象/指针/引用赋值给基类时这里会将基类以及包含基类虚表的那一部分一并切割。 #include iostream using namespace std; class Base1 { public: virtual void func1() { cout Base1::func1 endl; } virtual void func2() { cout Base1::func2 endl; } private: int b1; }; class Base2 { public: virtual void func1() { cout Base2::func1 endl; } virtual void func2() { cout Base2::func2 endl; } private: int b2; }; class Derive : public Base1, public Base2 { public: virtual void func1() { cout Derive::func1 endl; } virtual void func3() { cout Derive::func3 endl; } private: int d1; }; typedef void(*VFPTR)(); void PrintVTable(VFPTR vTable[]) { cout 虚表地址 vTable endl; for (int i 0; vTable[i] ! nullptr; i) { printf( 第%d个虚函数地址 :0X%x,-, i, vTable[i]); VFPTR f vTable[i]; f(); //函数指针的调用调用类中的虚函数 } cout endl; } int main() { Derive d; cout sizeof(Derive) endl; //输出20因为继承了两个父类有两个虚表 //这里的p1和p2的值不一样因为这里要发生切片将父类包含特有的子类切出来 Base1* p1 d; //切出Base1 Base2* p2 d; //切出Base2 VFPTR* vTableb1 (VFPTR*)(*(int*)d); PrintVTable(vTableb1); //这里要先跳转到包含Base2的虚表上然后找到虚表指针 VFPTR* vTableb2 (VFPTR*)(*(int*)((char*)d sizeof(Base1))); PrintVTable(vTableb2); return 0; } 观察下面结构图可以看出多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。 3菱形继承、菱形虚拟继承 实际中我们不建议设计出菱形继承及菱形虚拟继承一方面太复杂容易出问题另一方面使用这样的模型访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承的虚表我们可不做研究一般我们也不需要研究清楚因为实际中很少用。我们只需知道菱形继承往多继承方向理解菱形虚拟继承就很复杂了这里有很多问题不必深思。 四继承和多态常见的经典题型 继承与多态这方面有许多坑由于内部结构多变通常可设计出一些逻辑上的运算。这里我们来一一观察这方面的典型问题和经典面试问题。
1概念逻辑考察
1. 下面哪种面向对象的方法可以让你变得富有( A ) A: 继承 B : 封装 C : 多态 D : 抽象
2. ( D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关 而对方法的调用则可以关联于具体的对象。 A : 继承 B : 模板 C : 对象的自身引用 D : 动态绑定
3. 面向对象设计中的继承和组合下面说法错误的是 C A继承允许我们覆盖重写父类的实现细节父类的实现对于子类是可见的是一种静态复 用也称为白盒复用 B组合的对象不需要关心各自的实现细节之间的关系是在运行时候才确定的是一种动 态复用也称为黑盒复用 C优先使用继承而不是组合是面向对象设计的第二原则 D继承可以使子类能自动继承父类的接口但在设计模式中认为这是一种破坏了父类的封 装性的表现
4. 以下关于纯虚函数的说法, 正确的是( A ) A声明纯虚函数的类不能实例化对象 B声明纯虚函数的类是虚基类 C子类必须实现基类的纯虚函数 D纯虚函数必须是空函数
5. 关于虚函数的描述正确的是( B ) A派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B内联函数不能是虚函数 C派生类必须重新定义基类的虚函数 D虚函数可以是一个static型的函数
6. 关于虚表说法正确的是 D A一个类只能有一张虚表 B基类中有虚函数如果子类中没有重写基类的虚函数此时子类与基类共用同一张虚表 C虚表是在运行期间动态生成的 D一个类的不同对象共享该类的虚表
7. 假设A类中有虚函数B继承自AB重写A中的虚函数也没有定义任何虚函数则 D AA类对象的前4个字节存储虚表地址B类对象前4个字节不是虚表地址 BA类对象和B类对象前4个字节存储的都是虚基表的地址 CA类对象和B类对象前4个字节存储的虚表地址相同 DA类和B类虚表中虚函数个数相同但A类和B类使用的不是同一张虚表
8. 下面程序输出结果是什么? A #include iostream using namespace std; class A { public: A(const char* s) { cout s endl; } ~A() {} }; class B :virtual public A { public: B(const char* s1, const char* s2) :A(s1) { cout s2 endl; } }; class C :virtual public A { public: C(const char* s1, const char* s2) :A(s1) { cout s2 endl; } }; class D :public B, public C { public: D(const char* s1, const char* s2, const char* s3, const char* s4) :B(s1, s2), C(s1, s3), A(s1) { cout s4 endl; } }; int main() { D* p new D(class A, class B, class C, class D); delete p; return 0; } //菱形虚拟继承由于只有一个A所以当开始调用D的构造函数时会首先调用A的析构函数在B、C中不会调用A的构造函数。 Aclass A class B class C class D Bclass D class B class C class A Cclass D class C class B class A Dclass A class C class B class D
9. 多继承中指针偏移问题下面说法正确的是( C ) class Base1 { public: int _b1; }; class Base2 { public: int _b2; }; class Derive : public Base1, public Base2 { public: int _d; }; int main() { Derive d; Base1* p1 d; Base2* p2 d; Derive* p3 d; return 0; } Ap1 p2 p3 Bp1 p2 p3 Cp1 p3 ! p2 Dp1 ! p2 ! p3
10. 以下程序输出结果是什么 B class A { public: virtual void func(int val 1) { std::cout A- val std::endl; } virtual void test() { func(); } }; class B : public A { public: void func(int val 0) { std::cout B- val std::endl; } }; int main(int argc, char* argv[]) { B* p new B; p-test(); return 0; } A: A-0 B: B-1 C: A-1 D: B-0 E: 编译出错 F: 以上都不正确
2问答题
1. 什么是多态答多态分为静态多态和动态多态静态多态是编译器在编译时就能确定函数调用的是哪个实现如函数重载而动态多态则是在运行时才能确定如派生类重写虚函数时的调用。
2. 什么是重载、重写(覆盖)、重定义(隐藏)答参考以上图片内容
3. 多态的实现原理答多态的实现原理主要依赖于虚函数表和虚函数表指针通过虚函数表指针找到虚函数在运行时进行动态绑定以具体确定调用哪个函数。
4. inline函数可以是虚函数吗答可以不过编译器就忽略inline属性这个函数就不再是 inline因为inline修饰后若编译器看成内联函数那么此函数是没有地址的无法存入虚表中而虚函数是要放到虚表中去。
5. 静态成员可以是虚函数吗答不能因为类中存储的数据一切调用都需通过this指针包括虚函数表。静态成员函数没有this指针使用 类型::成员函数 的调用方式无法访问虚函数表所以静态成员函数无法放进虚函数表。
6. 构造函数可以是虚函数吗答不能因为对象中的虚函数表指针是在构造函数初始化列表 阶段才初始化的。
7. 析构函数可以是虚函数吗什么场景下析构函数是虚函数答可以并且最好把基类的析 构函数定义成虚函数。因为这里可能存在内存泄漏问题。当使用基类指针指向派生类地址空间时由于切割指针指向的是派生类中基类的地址所以这里结束时默认调用基类析构函数不会调用派生类析构函数这将会导致派生类中部分空间没有释放导致内存泄漏问题。因此这里需使用虚函数使其调用派生类的析构函数。
8. 对象访问普通函数快还是虚函数更快答首先如果是普通调用是一样快的。如果是多态调用则普通函数快因为多态调用构成多态运行时调用虚函数需要到虚函数表中去查找指定地址才能调用而普通函数直接调用。
9. 虚函数表是在什么阶段生成的存在哪的答虚函数表是在编译阶段就生成的一般情况 下存在代码段(常量区)的。
10. C菱形继承的问题虚继承的原理答菱形继承有二义性和数据冗余的问题。在继承前加上关键字virtual的继承是虚继承。虚继承是一种解决多重继承中菱形继承问题的方法注意这里不要把虚函数表和虚基表搞混了。
11. 什么是抽象类抽象类的作用答包含纯虚函数即在虚函数的后面写上 0 的类叫做抽象类。作用抽象类强制重写了虚函数另外抽象类体现出了接口继承关系。
