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

news2024/9/22 7:39:10

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

文章目录

前言
一、选择题
二、程序题
三、问答题

前言

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

一、选择题

下面哪种面向对象的方法可以让你变得富有(A )
A: 继承 B: 封装 C: 多态 D: 抽象
(D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，
而对方法的调用则可以关联于具体的对象。
A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定
面向对象设计中的继承和组合，下面说法错误的是？（C）
A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用
B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用
C：优先使用继承，而不是组合，是面向对象设计的第二原则
D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现
以下关于纯虚函数的说法,正确的是(A )
A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数
关于虚函数的描述正确的是( C)
A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数
关于虚表说法正确的是（ D）
A：一个类只能有一张虚表
B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
C：虚表是在运行期间动态生成的
D：一个类的不同对象共享该类的虚表
假设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，此时就是使用了基类的指针去调用虚函数，这个条件也满足了