头歌——C++实验12 多态(2024)

第1关：客观题

• 1、

  多态是指：C

  A、

  一个类可以派生出多个特殊类

  B、

  一个类可以有多个父类

  C、

  针对同一消息，不同对象可以以适合自身的方式加以响应

  D、

  一个对象可以由多个其他对象组合而成

• 2、

  如果一个类中至少有一个纯虚函数，则该类成为▁▁▁。

  填空1答案：抽象类

• 3、

  纯虚函数的声明格式为：▁▁▁ 函数类型 函数名(参数表)=▁▁▁。

  填空1答案：virtual

  填空2答案：0

• 4、

  虚函数与普通函数的区别就是声明时多了一个关键字▁▁▁。

  填空1答案：virtual

• 5、

  C++面向对象的三大属性为：ABC

  A、

  封装

  B、

  继承

  C、

  多态

  D、

  重用

• 6、

  派生类实现纯虚函数的参数与父类纯虚函数声明的参数可以不同。

  错误

• 7、

  虚函数的作用是用来实现多态。

  正确

• 8、

  抽象类可以有实例对象。

  错误

• 9、

  C++运行时的多态（动态多态）主要通过（ ）来实现。ABCD

  A、

  虚函数

  B、

  继承

  C、

  指针

  D、

  引用

• 10、

  下面程序的输出结果为：B

  1. #include <iostream>
  2. using namespace std;
  4. class A
  5. {
  6. public:
  7. virtual void f()
  8. {
  9. cout<<"A::f()"<<endl;
  10. }
  11. };
  12. class B : public A
  13. {
  14. private:
  15. virtual void f()
  16. {
  17. cout<<"B::f()"<<endl;
  18. }
  19. };
  21. int main()
  22. {
  23. A* pa = (A*)new B;
  24. pa->f();
  25. }
  A、

  A::f()

  B、

  B::f()

  C、

  编译错误

  D、

  不输出

第2关：请验证“使用虚函数”实例。

任务 请验证“使用虚函数”实例。

#include <iostream>
using namespace std;

class Pet 
{
public:
	/**********  Begin  **********/
	virtual void speak(){
        cout <<"how does a pet speak?\n";
    }
	
    /**********  End  **********/
};

/**********  Begin  **********/
class Cat : public Pet{
    public:
    void speak(){
        cout<<"miao~~!miao~~!\n";
    }
};
class Dog: public Pet{
    public :
    void speak(){
        cout <<"wang~~!wang~~!\n";
    }
};
	
/**********  End  **********/

int main() 
{
	/**********  Begin  **********/
	Pet *p1,*p2,obj;
    Dog dog1;
    Cat cat1;
    obj =dog1;
    obj.speak();
    p1=&cat1;
    p1->speak();
    p2=new Dog;
    p2->speak();
	
    /**********  End  **********/
	
	return 0;
}

第3关：请验证“纯虚函数和抽象类”实例。

任务 请验证“纯虚函数和抽象类”实例。

输入 无

预期输出

78.5398

30

#include <iostream>
using namespace std;

const double PI=3.1415926;

class Shape2D //Shape2D抽象类
{ 
public:
	/**********  Begin  **********/
	Shape2D(double x,double y):BaseX(x),BaseY(y){}
    virtual double Area()=0;
	
	/**********  End  **********/
protected:
	double BaseX,BaseY;
};

/**********  Begin  **********/
	class Circle:public Shape2D{
        public :
        Circle(double x,double y,double r) : Shape2D(x,y), radius(r){}
        double Area(){
            return PI*radius*radius;
        }
        private :
        double radius;
    };
class Rectangle:public Shape2D{
    public:
    Rectangle(double x,double y,double l,double w):Shape2D(x,y),Length(l),Width(w){}
    double Area(){
        return (Length-BaseX)*(Width-BaseY);
    }
   private :
    double Length,Width;
};

	
/**********  End  **********/

int main() 
{
	//求圆的面积 
	/**********  Begin  **********/
	Circle cir(1.0,1.0,5.0);
    double s1=cir.Area();
    cout<<s1<<endl;
	
	/**********  End  **********/
	
	//求矩形的面积
	/**********  Begin  **********/
	Rectangle rect(2.0,0.0,6.0,7.5);
    double s2 = rect.Area();
    cout<<s2<<endl;
	
	/**********  End  **********/
	
	return 0;
}

第4关：使用继承和多态实现整数计算器。

1、创建Operation父类： 具有2个私有整型数据成员：numA和numB 具有4个公有成员函数： 构造函数用于初始化数据成员，getNumA()和getNumB()用于获取数据成员的值，result()用于返回计算结果，设计为纯虚函数，且返回值类型为double。

2、创建4个派生类： Add类，Sub类，Mul类，Div类，分别用于完成加减乘除四则运算。除构造函数外，每个类需实现result()函数。在相除操作时需判断除数是否为0。

3、主函数： 创建1个父类型的指针，并分别用四个子类对其赋值，并调用result()方法。

输入1： 3 0 输出1： Add result is 3 Sub result is 3 Mul result is 0 Div result is division is 0

输入2： 10 20 输出2： Add result is 30 Sub result is -10 Mul result is 200 Div result is 0.5

#include <iostream>
#include <exception>
using namespace std;

class Operation {
public:
    // 构造函数
    Operation(int a, int b) : numA(a), numB(b) {}

    // 获取numA的值
    int getNumA() const {
        return numA;
    }

    // 获取numB的值
    int getNumB() const {
        return numB;
    }

    // 纯虚函数
    virtual double result() const = 0;

protected:
    int numA, numB;
};

// 加法类
class Add : public Operation {
public:
    Add(int a, int b) : Operation(a, b) {}

    double result() const override {
        return getNumA() + getNumB();
    }
};

// 减法类
class Sub : public Operation {
public:
    Sub(int a, int b) : Operation(a, b) {}

    double result() const override {
        return getNumA() - getNumB();
    }
};

// 乘法类
class Mul : public Operation {
public:
    Mul(int a, int b) : Operation(a, b) {}

    double result() const override {
        return getNumA() * getNumB();
    }
};

// 除法类
class Div : public Operation {
public:
    Div(int a, int b) : Operation(a, b) {}

    double result() const override {
        if (getNumB() == 0) {
            throw invalid_argument("division is 0");
        }
        return static_cast<double>(getNumA()) / getNumB();
    }
};

int main() {
    int a, b;
    cin >> a >> b;

    Add addOp(a, b);
    Sub subOp(a, b);
    Mul mulOp(a, b);
    Div divOp(a, b);

    try {
        cout << "Add result is " << addOp.result() << endl;
        cout << "Sub result is " << subOp.result() << endl;
        cout << "Mul result is " << mulOp.result() << endl;
        cout << "Div result is " << divOp.result() << endl;
    } catch (const exception& e) {
        cout << "" << e.what() << endl;
    }

    return 0;
}