C++面向对象程序设计上机练习二（继承和派生）

你的名字 2022-04-03 12:22 209阅读 0赞

## 1.继承基础填空B ##

### 试题描述 ###

筷子兄弟说：“你是我的小呀小苹果儿，就像天边最美的云朵。春天又来到了花开满山坡，种下希望就会收获……”。涩琪也喜欢小苹果，为了观察大家对小苹果的喜爱程度，他特意写了下面的程序代码，看看大家能不能从水果类中成功派生出苹果类。请你填写下面空白吧！

①    //必要的头文件等，可能为多条语句
       ②    //基类Fruit类
    {
          ③    //保护成员
          string color; //颜色
          string flavor; //味道
          float weight; //重量
          string kind; //种类
    
          ④    //公有成员
             ⑤    //无参构造函数，函数体可以为空
    
             ⑥    //设置种类SetKind()成员函数，一个string类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
    
             ⑦    //设置颜色SetColor()成员函数，一个string类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
    
             ⑧    //设置味道SetFlavor()成员函数，一个string类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
    
             ⑨    //设置重量SetWeight()成员函数，一个float类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
    
             ⑩    //返回重量常成员函数GetWeight()，函数无参数，返回值float类型，在函数体中将返回相应的数据成员
    };
    
       ⑪   	//定义派生类Apple，公有继承方式
    {
          ⑫    //定义无参构造函数，并在其中调用基类SetKind("苹果")函数，将字符串"苹果"作为参数
    };
    
    int main()
    {
          ⑬    //创建Apple类的对象a、b，并分别调用SetColor()、SetFlavor()函数。
    
          ⑭    //输入两个float类型的数据x和y，调用相应函数将x和y的值赋给a、b对象的数据成员weight。
    
       if (a.   ⑮    > b.   ⑯   )
          cout << setiosflags(ios::fixed) << setprecision(2) << "最重为a苹果" << a.   ⑰    << "克" << endl;
       else
          cout << setiosflags(ios::fixed) << setprecision(2) << "最重为b苹果" << b.   ⑱    << "克" << endl;
       return 0;
    }

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

### 输入 ###

输入两个float范围的浮点数，用一个空格隔开。

### 输出 ###

输出最重的苹果以及其重量。输出要求小数点后必须保留2位有效数字（四舍五入），不足补零。

### 输入示例1 ###

233.26 300.4

### 输出示例1 ###

最重为b苹果300.40克

### 输入示例2 ###

433.257 300.4

### 输出示例2 ###

最重为a苹果433.26克

### 数据范围 ###

输入float范围的浮点数

### 代码实现 ###

#include <iostream>
    #include <iomanip>
    using namespace std;
    class Fruit//基类Fruit类
    {
      protected://保护成员
          string color; //颜色
          string flavor; //味道
          float weight; //重量
          string kind; //种类
    
      public:
        //公有成员
          Fruit(){}//无参构造函数，函数体可以为空
    
          void SetKind(string k)//设置种类SetKind()成员函数，一个string类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
          {
              kind=k;
          }
          void SetColor(string c)//设置颜色SetColor()成员函数，一个string类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
          {
              color=c;
          }
          void SetFlavor(string f)//设置味道SetFlavor()成员函数，一个string类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
          {
              flavor=f;
          }
          void SetWeight(float w)//设置重量SetWeight()成员函数，一个float类型的参数，函数无返回值，在函数体中将参数赋给相应的数据成员
          {
              weight=w;
          }
          float GetWeight() const//返回重量常成员函数GetWeight()，函数无参数，返回值float类型，在函数体中将返回相应的数据成员
          {
              return weight;
          }
    };
    
    class Apple:public Fruit//定义派生类Apple，公有继承方式
    {
    public:
        Apple()//定义无参构造函数，并在其中调用基类SetKind("苹果")函数，将字符串"苹果"作为参数
        {
            Fruit::SetKind("苹果");
        }
    };
    
    int main()
    {
        Apple a,b;//创建Apple类的对象a、b，并分别调用SetColor()、SetFlavor()函数。
        a.SetColor("红");
        a.SetFlavor("甜");
        b.SetColor("黄");
        b.SetFlavor("酸");
        float x,y;//输入两个float类型的数据x和y，调用相应函数将x和y的值赋给a、b对象的数据成员weight。
        cin>>x>>y;
        a.SetWeight(x);
        b.SetWeight(y);
        if (a.GetWeight()> b.GetWeight())
          cout << setiosflags(ios::fixed) << setprecision(2) << "最重为a苹果" << a.GetWeight()<< "克" << endl;
        else
          cout << setiosflags(ios::fixed) << setprecision(2) << "最重为b苹果" << b.GetWeight()<< "克" << endl;
        return 0;
    }

## 2.子对象填空 ##

### 试题描述 ###

嘟嘟暑假去了埃及。在一个不知名的金字塔里翻到一张羊皮纸，纸上写着一些古怪的符号，还被虫蛀了一些洞。他不知道羊皮纸上写了些啥，慕名找到考古学家贝贝，贝贝也不认识这个东西。正巧你在贝贝家里做客，看到了这张纸上的符号。哇！这是你的专业呀，在大家崇拜的目光下，你大笔一挥，刷刷刷就把受损的羊皮纸还原了。

①    //必要的头文件等，可能为多条语句
       ②    //定义点类Point
    {
          ③    //定义保护数据成员：int类型的x和y
    
          ④    //无参默认构造函数，在函数体中初始化数据成员x和y为0
    
          ⑤    //有两个参数（参数没有默认值）的构造函数，在函数体中将形参x1和y1分别赋给数据成员x和y
    
          ⑥    //设置x坐标的函数setX(int), 将形参x1赋给数据成员x
    
          ⑦    //设置y坐标的函数setY(int), 将形参y1赋给数据成员y
    
          ⑧    //返回x坐标的函数getX()
    
          ⑨    //返回y坐标的函数getY()
    };
    class Circle
    {
          ⑩    //定义保护数据成员：Point类型的圆心坐标center，int类型的半径radius
    
          ⑪    //默认构造函数，在初始化列表中初始化子对象center，设置圆心坐标为0和0；在函数体中，设置radius半径为0
    
          ⑫    //有三个参数x1、y1和r1的构造函数，在初始化列表中初始化子对象center，设置圆心坐标为x1和y1；在函数体中，设置radius半径为r1
    
          ⑬    //计算并返回圆面积常成员函数area()，pi使用3.14。
    
          ⑭    //返回圆心坐标center的x坐标的成员函数getX()。
    
          ⑮    //返回圆心坐标center的y坐标的成员函数getY()
    };
    int main()
    {
       int x1, y1, r1;
       cin >> x1 >> y1 >> r1;
       Circle a(x1, y1, r1), b;
          ⑯    << "创建了2个圆对象a和b" << endl;
       cout << "圆a的圆心坐标" <<    ⑰    << "和" <<    ⑱    << endl;
       cout << "圆b的圆心坐标" <<    ⑲    << "和" <<    ⑳    << endl;
       cout << "圆a的面积为" <<    ⑳    //注意面积输出要求小数点后必须保留2位有效数字（四舍五入），不足补零
       cout << "圆b的面积为" <<    ⑳    //注意面积输出要求小数点后必须保留2位有效数字（四舍五入），不足补零
       return 0;
    }

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

### 输入 ###

输入三个整数，相邻两数之间以空格隔开。

### 输出 ###

依据题意输出若干行。注意面积输出要求小数点后必须保留2位有效数字（四舍五入），不足补零。

### 输入示例 ###

1 1 1

### 输出示例 ###

创建了2个圆对象a和b  
圆a的圆心坐标1和1  
圆b的圆心坐标0和0  
圆a的面积为3.14  
圆b的面积为0.00

### 数据范围 ###

输入int范围的非负整数

### 代码实现 ###

#include <iostream>
    #include <iomanip>
    #define pi 3.14
    using namespace std;
    class Point//定义点类Point
    {
    protected:
        int x,y;//定义保护数据成员：int类型的x和y
    public:
        Point()//无参默认构造函数，在函数体中初始化数据成员x和y为0
        {
            x=y=0;
        }
        Point(int x1,int y1)//有两个参数（参数没有默认值）的构造函数，在函数体中将形参x1和y1分别赋给数据成员x和y
        {
            x=x1;
            y=y1;
        }
        void setX(int x1)//设置x坐标的函数setX(int), 将形参x1赋给数据成员x
        {
            x=x1;
        }
        void setY(int y1)//设置y坐标的函数setY(int), 将形参y1赋给数据成员y
        {
            y=y1;
        }
        int getX()//返回x坐标的函数getX()
        {
            return x;
        }
        int getY()//返回y坐标的函数getY()
        {
            return y;
        }
    };
    class Circle
    {
    protected://定义保护数据成员：Point类型的圆心坐标center，int类型的半径radius
        Point center;
        int radius;
    public://默认构造函数，在初始化列表中初始化子对象center，设置圆心坐标为0和0；在函数体中，设置radius半径为0
        Circle():center(0,0)
        {
            radius=0;
        }
        Circle(int x1,int y1,int r1):center(x1,y1)//有三个参数x1、y1和r1的构造函数，在初始化列表中初始化子对象center，设置圆心坐标为x1和y1；在函数体中，设置radius半径为r1
        {
            radius=r1;
        }
        double area()//计算并返回圆面积常成员函数area()，pi使用3.14。
        {
            return pi*radius*radius;
        }
        int getX()//返回圆心坐标center的x坐标的成员函数getX()。
        {
            return center.getX();
        }
        int getY()//返回圆心坐标center的y坐标的成员函数getY()
        {
            return center.getY();
        }
    };
    int main()
    {
       int x1, y1, r1;
       cin >> x1 >> y1 >> r1;
       Circle a(x1, y1, r1), b;
       cout<< "创建了2个圆对象a和b" << endl;
       cout << "圆a的圆心坐标" <<a.Circle::getX()<< "和" <<a.Circle::getY()<< endl;
       cout << "圆b的圆心坐标" <<b.Circle::getX()<< "和" <<b.Circle::getY()<< endl;
       cout << "圆a的面积为" <<setiosflags(ios::fixed)<<setprecision(2)<<a.area()<<endl;
       //注意面积输出要求小数点后必须保留2位有效数字（四舍五入），不足补零
       cout << "圆b的面积为" <<setiosflags(ios::fixed)<<setprecision(2)<<b.area()<<endl;//注意面积输出要求小数点后必须保留2位有效数字（四舍五入），不足补零
       return 0;
    }

## 3.继承之球类 ##

### 试题描述 ###

彼得潘在永无岛学会了使用继承来提高代码重用性，他要尽快把继承传授给温蒂以及她的弟弟们。彼得潘先写好了一个简单的Circle圆类。  
现在要求温蒂和她的弟弟们从Circle公有派生出Sphere球类，在派生类中必须重新定义GetArea()常成员函数计算并返回球表面积，增加GetVolume()常成员函数计算并返回球体积。彼得潘知道温蒂和她的弟弟们记不住球表面积和体积计算公式，所以把计算公式也给了她们（很贴心哦！）。温蒂请你帮助她定义子类Sphere。  
球的表面积计算公式： 4 \* 3.14 \* radius \* radius  
球的体积计算公式：(4.0 / 3) \* 3.14 \* radius \* radius \* radius

class Circle //基类Circle
    {
       protected:
          double radius; //圆半径
       public:
          void SetRadius(double r) //设置半径函数
          {
             radius = r;
          }
          double GetArea() const //返回圆面积常成员函数
          {
             return 3.14 * radius * radius;
          }
    };
    int main()
    {
       double r;
       cin >> r;
       Sphere s; //创建派生类Sphere的对象球s
       s.SetRadius(r); //调用基类函数设置球s的半径
       cout << "球的表面积和体积为：" << setiosflags(ios::fixed) << setprecision(2) << s.GetArea() << ", " << s.GetVolume() << endl;
       cout << "把球从中间劈开，横切面的面积为：" << s.Circle::GetArea() << endl;
       return 0;
    }

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

### 输入 ###

输入一个double范围的浮点数。

### 输出 ###

依据题意输出球的表面积和体积、横切面的面积。输出要求小数点后必须保留2位有效数字（四舍五入），不足补零。

### 输入示例 ###

### 输出示例 ###

球的表面积和体积为：12.56, 4.19  
把球从中间劈开，横切面的面积为：3.14

### 数据范围 ###

输入double范围的浮点数

### 代码实现 ###

#include <iostream>
    #include <iomanip>
    #define pi 3.14
    using namespace std;
    class Circle //基类Circle
    {
       protected:
          double radius; //圆半径
       public:
          void SetRadius(double r) //设置半径函数
          {
             radius = r;
          }
          double GetArea() const //返回圆面积常成员函数
          {
             return 3.14 * radius * radius;
          }
    };
    class Sphere:public Circle
    {
    public:
        double GetArea() const
        {
            return 4*3.14*radius*radius;
        }
        double GetVolume()
        {
            return (4.0/3)*3.14*radius*radius*radius;
        }
    };
    int main()
    {
       double r;
       cin >> r;
       Sphere s; //创建派生类Sphere的对象球s
       s.SetRadius(r); //调用基类函数设置球s的半径
       cout << "球的表面积和体积为：" << setiosflags(ios::fixed) << setprecision(2) << s.GetArea() << ", " << s.GetVolume() << endl;
       cout << "把球从中间劈开，横切面的面积为：" << s.Circle::GetArea() << endl;
       return 0;
    }

## 4.多重继承之继承者们填空 ##

### 试题描述 ###

下面的代码实现如下图所示的继承关系，请特别注意的是类A1公有派生类B，而类A2私有派生类B。  
继承图![在这里插入图片描述][Image 1]  
请仔细阅读，补充下面代码中的空白。

①    //必要的头文件等，可能为多条语句
       ②    //基类A1类
    {
          ③    //保护成员
          int a1;
          ④    //公有成员
             ⑤    //带有一个参数a的构造函数（且参数有默认值0），在初始化列表中使用a的值初始化数据成员a1，函数体如下：
          {
             cout << "执行基类A1的构造函数" << endl;
          }
             ⑥    //析构函数，函数体如下：
          {
             cout << "执行基类A1的析构函数" << endl;
          }
          void ShowA1() const //输出数据成员到屏幕
          {
             cout << "A1::a1=" << a1 << endl;
          }
    };
       ⑦    //基类A2类
    {
          ⑧    //保护成员
          int a2;
          ⑨    //公有成员
             ⑩    //带有一个参数a的构造函数（且参数有默认值0），在初始化列表中使用a的值初始化数据成员a2，函数体如下：
          {
             cout << "执行基类A2的构造函数" << endl;
          }
             ⑪    //析构函数，函数体如下：
          {
             cout << "执行基类A2的析构函数" << endl;
          }
          void ShowA2() const //输出数据成员到屏幕
          {
             cout << "A2::a2=" << a2 << endl;
          }
    };
       ⑫    //派生类B从A1公有继承，从A2私有继承
    {
          ⑬    //公有成员
             ⑭    //带有两个参数a1、a2的构造函数（且参数均有默认值0），在初始化列表中分别调用基类A1、A2的构造函数，并传递相应的参数，函数体如下：
          {
             cout << "执行派生类B的构造函数" << endl;
          }
             ⑮    //析构函数，函数体如下：
          {
             cout << "执行派生类B的析构函数" << endl;
          }
             ⑯    //输出常成员函数
          {
                ⑰    //调用基类函数ShowA1()
                ⑱    //调用基类函数ShowA2()
          }
    };
    int main()
    {
       int x, y;
       cin >> x >> y;
       B obj(x, y); //创建派生类B对象obj
       obj.Show();
       obj.ShowA1();
       return 0;
    }

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

### 输入 ###

输入两个正数，两项之间以空格隔开。

### 输出 ###

依据题意输出若干行。

### 输入示例 ###

1 2

### 输出示例 ###

执行基类A1的构造函数  
执行基类A2的构造函数  
执行派生类B的构造函数  
A1::a1=1  
A2::a2=2  
A1::a1=1  
执行派生类B的析构函数  
执行基类A2的析构函数  
执行基类A1的析构函数

### 数据范围 ###

输入为int范围的整数

### 代码实现 ###

#include <iostream>
    #include <iomanip>
    using namespace std;
    class A1//基类A1类
    {
    protected://保护成员
          int a1;
    public://公有成员
          A1(int a=0):a1(a)//带有一个参数a的构造函数（且参数有默认值0），在初始化列表中使用a的值初始化数据成员a1，函数体如下：
          {
             cout << "执行基类A1的构造函数" << endl;
          }
          ~A1()//析构函数，函数体如下：
          {
             cout << "执行基类A1的析构函数" << endl;
          }
          void ShowA1() const //输出数据成员到屏幕
          {
             cout << "A1::a1=" << a1 << endl;
          }
    };
    class A2//基类A2类
    {
    protected://保护成员
          int a2;
    public://公有成员
          A2(int a=0):a2(a)//带有一个参数a的构造函数（且参数有默认值0），在初始化列表中使用a的值初始化数据成员a2，函数体如下：
          {
             cout << "执行基类A2的构造函数" << endl;
          }
          ~A2()//析构函数，函数体如下：
          {
             cout << "执行基类A2的析构函数" << endl;
          }
          void ShowA2() const //输出数据成员到屏幕
          {
             cout << "A2::a2=" << a2 << endl;
          }
    };
    class B:public A1,private A2//派生类B从A1公有继承，从A2私有继承
    {
    public://公有成员
          B(int a1=0,int a2=0):A1(a1),A2(a2)//带有两个参数a1、a2的构造函数（且参数均有默认值0），在初始化列表中分别调用基类A1、A2的构造函数，并传递相应的参数，函数体如下：
          {
             cout << "执行派生类B的构造函数" << endl;
          }
          ~B()//析构函数，函数体如下：
          {
             cout << "执行派生类B的析构函数" << endl;
          }
          void Show() const//输出常成员函数
          {
              ShowA1();//调用基类函数ShowA1()
              A2::ShowA2();//调用基类函数ShowA2()
          }
    };
    int main()
    {
       int x, y;
       cin >> x >> y;
       B obj(x, y); //创建派生类B对象obj
       obj.Show();
       obj.ShowA1();
       return 0;
    }

## 5.虚基类之员工分类管理 ##

### 试题描述 ###

继承关系如下图所示，所有继承关系均为公有继承。  
![在这里插入图片描述][Image 1]  
类成员描述分别如表1、表2、表3和表4所示。提示：为了保证教职工人数正确，请使用虚基类。为了简化问题，不考虑有员工离职的情况。  
![在这里插入图片描述][Image 1]![在这里插入图片描述][Image 1]![在这里插入图片描述][Image 1]![在这里插入图片描述][Image 1]

int main()
    {
       Teacher t1("孔子","儒家文学"); //创建教学类员工t1
       Teacher t2 ("公输班","建筑学");
       Officer o1("端木赐","财务科长"); //创建教辅类员工o1
       Teacher_Officer to3("颜回","儒家文学","副院长");//创建教师教辅类员工to3
    
       cout << "共有教职工" << Staff::GetStaffCount() << "人" << endl;
       cout << t1.GetCode() << ", " << t1.GetName() << ", " << t1.GetSubject() << endl;
       cout << t2.GetCode() << ", " << t2.GetName() << ", " << t2.GetSubject() << endl;
       cout << o1.GetCode() << ", " << o1.GetName() << ", " << o1.GetWork() << endl;
       cout << to3.GetCode() << ", " << to3.GetName() << ", " << to3.GetSubject() << ", " << to3.GetWork() << endl;
       return 0;
    }

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

### 输出示例 ###

共有教职工4人  
1, 孔子, 儒家文学  
2, 公输班, 建筑学  
3, 端木赐, 财务科长  
4, 颜回, 儒家文学, 副院长

### 代码实现 ###

#include <iostream>
    #include <string>
    #include <iomanip>
    using namespace std;
    class Staff
    {
    protected:
        int code;
        string name;
        static int count;
    public:
        Staff(string n)
        {
            name=n;
            code=count;
            count++;
        }
        void SetName(string n)
        {
            name=n;
        }
        string GetName()
        {
            return name;
        }
        int GetCode()
        {
            return code;
        }
        static int GetStaffCount()
        {
            return count-1;
        }
    };
    int Staff::count=1;
    class Teacher:virtual public Staff
    {
    protected:
        string subject;
    public:
        Teacher(string n,string s):Staff(n),subject(s){}
        void SetSubject(string s)
        {
            subject=s;
        }
        string GetSubject()
        {
            return subject;
        }
    };
    class Officer:virtual public Staff
    {
    protected:
        string work;
    public:
        Officer(string n,string w):Staff(n),work(w){}
        void SetWork(string w)
        {
            work=w;
        }
        string GetWork()
        {
            return work;
        }
    };
    class Teacher_Officer:public Teacher,public Officer
    {
    public:
        Teacher_Officer(string n,string s,string w):Staff(n), Teacher(n, s), Officer(n, w){}
    };
    
    int main()
    {
       Teacher t1("孔子","儒家文学"); //创建教学类员工t1
       Teacher t2 ("公输班","建筑学");
       Officer o1("端木赐","财务科长"); //创建教辅类员工o1
       Teacher_Officer to3("颜回","儒家文学","副院长");//创建教师教辅类员工to3
    
       cout << "共有教职工" << Staff::GetStaffCount() << "人" << endl;
       cout << t1.GetCode() << ", " << t1.GetName() << ", " << t1.GetSubject() << endl;
       cout << t2.GetCode() << ", " << t2.GetName() << ", " << t2.GetSubject() << endl;
       cout << o1.GetCode() << ", " << o1.GetName() << ", " << o1.GetWork() << endl;
       cout << to3.GetCode() << ", " << to3.GetName() << ", " << to3.GetSubject() << ", " << to3.GetWork() << endl;
       return 0;
    }

[Image 1]: