【C++】-多态的经典题目

💖作者：小树苗渴望变成参天大树🎈
🎉作者宣言：认真写好每一篇博客💤
🎊作者gitee:gitee✨
💞作者专栏：C语言,数据结构初阶,Linux,C++ 动态规划算法🎄
如 果 你 喜 欢 作 者 的 文 章 ，就 给 作 者 点 点 关 注 吧！

---

前言

今天博主专门出一篇继承和多态的相关的题目，为了就是让大家更好的进行掌握继承和多态，而且这里面有几题是比较坑的。我会一一给大家解释清楚的，话不多说，我们开始进入正文

---

一、选择题

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. 关于虚函数的描述正确的是( C)
   A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
   C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数
6. 关于虚表说法正确的是（ D）
   A：一个类只能有一张虚表
   B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
   C：虚表是在运行期间动态生成的
   D：一个类的不同对象共享该类的虚表
7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ C）
   A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
   B：A类对象和B类对象前4个字节存储的都是虚基表的地址
   C：A类对象和B类对象前4个字节存储的虚表地址相同
   D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

二、程序题

#include<iostream>
using namespace std;
class A{
public:
	  A(char *s) { cout<<s<<endl; }
	 ~A(){}
};

class B:virtual public A
{
public:
	 B(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};

class C:virtual public A
{
public:
	 C(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};

class D:public B,public C
{
public:
 	D(char *s1,char *s2,char *s3,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：class A class B class C class D B：class D class B class C class A
C：class D class C class B class A D：class A class C class B class D

这题是非常的坑的，我们发现这是一个菱形继承，而且使用的virtual解决了数据冗余和二义性的,我们重复的数据就是基类里面的，现在我们的基类的里面的内容本来在B里面和C里面都有，现在在公共的地方，所以此时的问题就是就变成了，我们A的构造函数调用几次的问题，因为是我们创建d对像，所以我们是D类的构造函数去调用A的构造函数，而B，C类中关于A类的构造函数那一部分就失效了，先进行父类的构造在进行子类的构造，先继承的先构造，所以此题的选择是A

但是B,C构造函数里面的调用A的构造函数不能去掉，因为B,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;
}

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

这题在之前也有在之前也有对应的暗示，我们来画一个图来理解，因为不是多态，就是普通调用

此题的正确答案就是C

   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: 以上都不正确

这题我们要了解多态的调用，虚函数重写的本质什么，构成多态的条件是什么
这题构成多态吗？

首先我们看符不符合
第一点：构不构成虚函数的重写
我们看到fun的父类加了virtual子类加不加无所谓，也符合三同，我们的参数列表只要求类型一样就行了，第一点是满足了
第二点：基类的指针或者引用去调用
我们发现先通过调用fun是通过test去调用，而test虽然是虚函数但是没有重写，但继承到子类B的虚表里面的了，我们创建一个子类对象的指针，去调用test也是调用父类的，此时的this指针就是父类的，然后再去调用fun,就相当于this->fun，此时就是使用了基类的指针去调用虚函数，这个条件也满足了

通过上面两点的分析我们知道构成多态，我们p是指向子类对象的，按道理答案是D，但是这题却不是的，因为我们子类是重写了虚函数的定义，使用虚函数的头，定义使用自己的，所以答案是B,现实中没人这么设计，好好的吧参数给的值不一样干嘛呢，没什么意义。

三、问答题

1. 什么是多态？

现在从两点回答1.静态的多态（函数重载）2.动态的多态（继承中的虚函数重写），两种都是更方便和灵活的多种形态的调用

2. 多态的实现原理？

第一种是靠函数名修饰规则，第二种是虚函数表

3. inline函数可以是虚函数吗？

答案是可以的，只是inline的特性就被忽略了，优先是虚函数。

4. 静态成员可以是虚函数吗？

答：不能，编译时强制报错，不允许这样的语法存在因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

5. 构造函数可以是虚函数吗？

答：不能，因为对象中的虚函数表指针是在构造函数初始化列表
阶段才初始化的,是在构造的时候有了虚函数表指针，然后再走初始化列表，构造在前，虚表指在后，所以不能

6. 对象访问普通函数快还是虚函数更快？

答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

7. 虚函数表是在什么阶段生成的

答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

注意：virtual关键在菱形继承的时候用过，里面的指针式虚基表的指针，指向的是存的偏移量的地方，在多态里面也使用了，里面存放的虚表指针，指向的是虚函数存放的地方

今天的题目分享就到这里了，大家下去自己去理解一下吧