【无标题】

【id:297】【10分】J. OOP租车系统（多重继承）

题目描述

各位面向对象的小伙伴们，在学习了面向对象的核心概念——类的封装、继承、多态之后，答答租车系统开始营运了。
请你充分利用面向对象思想，为公司解决智能租车问题，根据客户选定的车型和租车天数，来计算租车费用，最大载客人数，最大载载重量。
公司现有三种车型（客车、皮卡车、货车），每种车都有名称和租金的属性；其中：客车只能载人，货车只能载货，皮卡车是客货两用车，即可以载人，也可以载货。
下面是答答租车公司的可用车型、容量及价目表：
序号     名称     载客量      载货量        租金
                           （人）     （吨）    （元/天）
  1          A            5                                 800
  2          B            5                                 400
  3          C            5                                 800
  4          D            51                             1300
  5          E            55                             1500
  6          F             5            0.45             500
  7         G             5             2.0               450
  8         H                            3                  200
  9          I                             25              1500
 10        J                             35              2000
要求：根据客户输入的所租车型的序号及天数，计算所能乘载的总人数、货物总数量及租车费用总金额。

输入

首行是一个整数：代表要不要租车 1——要租车（程序继续），0——不租车（程序结束）；
第二行是一个整数，代表要租车的数量N；
接下来是N行数据，每行2个整数m和n，其中：m表示要租车的编号，n表示租用该车型的天数。

输出

若成功租车，则输出一行数据，数据间有一个空格，含义为：
载客总人数 载货总重量（保留2位小数） 租车金额（整数）
若不租车，则输出： 
0 0.00 0（含义同上）

输入样例1

1
2
1 1
2 2

输入样例

15 0.00 1600

AC代码

#include<bits/stdc++.h>

using namespace std;

class Car{
protected:
    int id;
    string name;
    int zujin;
public:
    Car(){}
    ~Car(){}
    Car(int id_, string name_, int zujin_){
        this->id = id_;
        this->name = name_;
        this->zujin = zujin_;
    }
};

class Keche: public Car{
protected:
    int zaikeliang;
public:
    Keche(){}
    ~Keche(){}
    Keche(int id_, string name_, int zujin_, int zaikeliang_){
        this->id = id_;
        this->name = name_;
        this->zujin = zujin_;
        this->zaikeliang = zaikeliang_;
    }
    int getId(){
        return this->id;
    }
    string getName(){
        return this->name;
    }
    int getZujin(){
        return this->zujin;
    }
    int getZaikeliang(){
        return this->zaikeliang;
    }
};

class Huoche: public Car{
protected:
    double zaihuoliang;
public:
    Huoche(){}
    ~Huoche(){}
    Huoche(int id_, string name_, int zujin_, double zaihuoliang_){
        this->id = id_;
        this->name = name_;
        this->zujin = zujin_;
        this->zaihuoliang = zaihuoliang_;
    }
    int getId(){
        return this->id;
    }
    string getName(){
        return this->name;
    }
    int getZujin(){
        return this->zujin;
    }
    double getZaihuoliang(){
        return this->zaihuoliang;
    }
};

class Pikache:public Keche, public Huoche{
public:
    Pikache(){}
    ~Pikache(){}
    Pikache(int id_, string name_, int zujin_, int zaikeliang_, double zaihuoliang_){
        Keche::id = id_;
        Keche::name = name_;
        Keche::zujin = zujin_;
        this->zaikeliang = zaikeliang_;
        this->zaihuoliang = zaihuoliang_;
    }
    int getId(){
        return Keche::id;
    }
    string getName(){
        return Keche::name;
    }
    int getZujin(){
        return Keche::zujin;
    }
    int getZaikeliang(){
        return this->zaikeliang;
    }
    double getZaihuoliang(){
        return this->zaihuoliang;
    }
};

int main()
{
    Keche keche1(1,"A",800,5);
    Keche keche2(2,"B",400,5);
    Keche keche3(3,"C",800,5);
    Keche keche4(4,"D",1300,51);
    Keche keche5(5,"E",1500,55);
    Pikache pikache6(6,"F",500,5,0.45);
    Pikache pikache7(7,"G",450,5,2.0);
    Huoche huoche8(8,"H",200,3);
    Huoche huoche9(9,"I",1500,25);
    Huoche huoche10(10,"J",2000,35);

    int checknum;
    cin >> checknum;
    if(checknum)
    {
        int N;
        cin >> N;
        int sum_zaikeliang = 0;
        double sum_zaihuoliang = 0;
        int sum_zujin = 0;
        while(N--)
        {
            int m,n;
            cin >> m >> n;
            switch(m)
            {
                case 1:
                    sum_zaikeliang += keche1.getZaikeliang() * n;
                    sum_zujin += keche1.getZujin() * n;
                    break;
                case 2:
                    sum_zaikeliang += keche2.getZaikeliang() * n;
                    sum_zujin += keche2.getZujin() * n;
                    break;
                case 3:
                    sum_zaikeliang += keche3.getZaikeliang() * n;
                    sum_zujin += keche3.getZujin() * n;
                    break;
                case 4:
                    sum_zaikeliang += keche4.getZaikeliang() * n;
                    sum_zujin += keche4.getZujin() * n;
                    break;
                case 5:
                    sum_zaikeliang += keche5.getZaikeliang() * n;
                    sum_zujin += keche5.getZujin() * n;
                    break;
                case 6:
                    sum_zaikeliang += pikache6.getZaikeliang() * n;
                    sum_zaihuoliang += pikache6.getZaihuoliang() * n;
                    sum_zujin += pikache6.getZujin() * n;
                    break;
                case 7:
                    sum_zaikeliang += pikache7.getZaikeliang() * n;
                    sum_zaihuoliang += pikache7.getZaihuoliang() * n;
                    sum_zujin += pikache7.getZujin() * n;
                    break;
                case 8:
                    sum_zaihuoliang += huoche8.getZaihuoliang() * n;
                    sum_zujin += huoche8.getZujin() * n;
                    break;
                case 9:
                    sum_zaihuoliang += huoche9.getZaihuoliang() * n;
                    sum_zujin += huoche9.getZujin() * n;
                    break;
                default:
                    sum_zaihuoliang += huoche10.getZaihuoliang() * n;
                    sum_zujin += huoche10.getZujin() * n;
                    break;
            }
        }
        printf("%d %.2lf %d\n",sum_zaikeliang, sum_zaihuoliang, sum_zujin);

    }
    else
    {
        cout << "0 " << "0.00 " << "0" << endl;
    }
    return 0;
}