深圳技术大学c++ 多重继承

【id:296】【20分】A. OOP 学生综合评价（虚函数和多态）

时间限制1s

内存限制128MB

题目描述

定义学生类框架如下：

class Student{

protected:

  string name; //学生姓名

  int type; //学生类别:1表示本科生，2表示研究生

  int courses[3]; //3门课的成绩

  string courseGrade; //成绩等级

public:

  Student(string n,string t,int a1,int a2,int a3);//构造方法

  virtual void calculateGrade()=0;//计算成绩等级

  void print();//输出信息

}

要求如下：

1.请设计3个类，分别是学生类Student，本科生类Undergraduate，研究生类Postgraduate，其中Student类是基类，它包含基本的学生信息，如姓名、类别（本科生还是研究生）、所学课程（这里假定为3门课，用数组表示）成绩和成绩等级等；

2.Undergraduate类和Postgraduate都是Student类的派生类，它们之间的主要差别是计算3门课程平均成绩等级的方法有所不同，研究生的标准要比本科生的标准高一些，如下表所示：

3.以Student为基类，构建出Undergraduate、Postgraduate两个类。

4.要求主函数中有一个基类指针，生成基类动态数组，来接收子类对象。

输入

第一行表示测试次数。

从第二行开始，每个测试用例占一行，每行数据意义如下：学生姓名、学生类别（1为本科生，2为研究生）、3门课的成绩。

输出

学生姓名、类别、成绩等级

#include <bits/stdc++.h>
using namespace std;
class Student {
protected:
    string name;
    int type;
    int courses[3];
    string courseGrade;
public:
    Student(string n, int t, int a1, int a2, int a3) : name(n), type(t) {
        courses[0] = a1;
        courses[1] = a2;
        courses[2] = a3;
    }
    virtual void calculateGrade() = 0;
    void print() {
        cout << name << ',' << (type == 1 ? "本科生" : "研究生") << ',' << courseGrade << endl;
    }
};

class Undergraduate : public Student {
public:
    Undergraduate(string n, int t, int a1, int a2, int a3) : Student(n, t, a1, a2, a3) {
        calculateGrade();
    }
    void calculateGrade() override {
        int avg = (courses[0] + courses[1] + courses[2]) / 3;
        if (avg >= 80)
            courseGrade = "优秀";
        else if (avg >= 70)
            courseGrade = "良好";
        else if (avg >= 60)
            courseGrade = "一般";
        else if (avg >= 50)
            courseGrade = "及格";
        else
            courseGrade = "不及格";
    }
};

class Postgraduate : public Student {
public:
    Postgraduate(string n, int t, int a1, int a2, int a3) : Student(n, t, a1, a2, a3) {
        calculateGrade();
    }
    void calculateGrade() override {
        int avg = (courses[0] + courses[1] + courses[2]) / 3;
        if (avg >= 90)
            courseGrade = "优秀";
        else if (avg >= 80)
            courseGrade = "良好";
        else if (avg >= 70)
            courseGrade = "一般";
        else if (avg >= 60)
            courseGrade = "及格";
        else
            courseGrade = "不及格";
    }
};

int main() {
    int testCases;
    cin >> testCases;
    Student** students = new Student * [testCases];
    for (int i = 0; i < testCases; i++) {
        string name;
        int type, a1, a2, a3;
        cin >> name >> type >> a1 >> a2 >> a3;
        if (type == 1)
            students[i] = new Undergraduate(name, type, a1, a2, a3);
        else 
            students[i] = new Postgraduate(name, type, a1, a2, a3);
    }
    for (int i = 0; i < testCases; i++) {
        students[i]->print();
        delete students[i];
    }
    delete[] students;
    return 0;
}

【id:70】【20分】B. 在职研究生（多重继承）

时间限制1s

内存限制128MB

题目描述

1、建立如下的类继承结构：

1)  定义一个人员类CPeople，其属性（保护类型）有：姓名、性别、年龄；

2)  从CPeople类派生出学生类CStudent，添加属性：学号和入学成绩；

3)  从CPeople类再派生出教师类CTeacher，添加属性：职务、部门；

4)   从CStudent和CTeacher类共同派生出在职研究生类CGradOnWork，添加属性：研究方向、导师；

2、分别定义以上类的构造函数、输出函数print及其他函数（如需要）。

3、在主函数中定义各种类的对象，并测试之。

输入

第一行：姓名性别年龄，姓名的最大字符长度为20

第二行：学号成绩

第三行：职务部门，职务和部门的最大字符长度均为20

第四行：研究方向导师，研究方向和导师的最大长度均为20

输出

第一行：People:

第二行及以后各行：格式见Sample

#include <bits/stdc++.h>
using namespace std;
class CPeople
{
protected:
    string name;
    string sex;
    int age;
public:
    CPeople(string name,string sex,int age) : name(name),sex(sex),age(age) {}
    virtual void print()
    {
        cout << "People:\n";
        cout << "Name: " << name << '\n' << "Sex: " << sex << '\n' << "Age: " << age << '\n' << '\n';
    }
};
class CStudent : virtual public CPeople
{
protected:
    string card;
    double grade;
public:
    CStudent(string name, string sex, int age, string card, double grade)
        : CPeople(name, sex, age), card(card), grade(grade)
    {}
    void print() override
    {
        cout << "Student:\n";
        cout << "Name: " << name << '\n' << "Sex: " << sex << '\n' << "Age: " << age << '\n';
        cout << "No.: " << card << '\n' << "Score: " << grade << '\n' << '\n';
    }
};
class CTeacher : virtual public CPeople
{
protected:
    string position;
    string department;
public:
    CTeacher(string name, string sex, int age, string position, string department)
        : CPeople(name, sex, age), position(position), department(department)
    {}
    void print() override
    {
        cout << "Teacher:\n";
        cout << "Name: " << name << '\n' << "Sex: " << sex << '\n' << "Age: " << age << '\n';
        cout << "Position: " << position << '\n' << "Department: " << department << '\n' << '\n';
    }
};
class CGradOnWork : public CStudent, public CTeacher
{
protected:
    string researchArea;
    string tutor;
public:
    CGradOnWork(string name, string sex, int age, string card, double grade, string position, string department, string researchArea, string tutor)
        : CPeople(name, sex, age), CStudent(name, sex, age, card, grade), CTeacher(name,sex, age, position, department), researchArea(researchArea), tutor(tutor) 
    {}
    void print() override
    {
        CPeople::print();
        CStudent::print();
        CTeacher::print();
        cout << "GradOnWork:\n";
        cout << "Name: " << name << '\n' << "Sex: " << sex << '\n' << "Age: " << age << '\n';
        cout << "No.: " << card << '\n' << "Score: " << grade << '\n';
        cout << "Position: " << position << '\n' << "Department: " << department << '\n';
        cout << "Direction: " << this->researchArea << '\n' << "Tutor: " << this->tutor;
    }
};

int main() 
{
    string name, sex;
    int age;
    cin >> name >> sex >> age;
    string card;
    double grade;
    cin >> card >> grade;
    string position, department;
    cin >> position >> department;
    string researchArea, tutor;
    cin >> researchArea >> tutor;
    /以上为输入
    CGradOnWork grad(name, sex, age, card, grade, position, department, researchArea, tutor);
    grad.print();
    return 0;
}

【id:72】【20分】C. 交通工具（多重继承）

时间限制1s

内存限制128MB

题目描述

1、建立如下的类继承结构：

1)一个车类CVehicle作为基类，具有max_speed、speed、weight等数据成员，display()等成员函数

2)从CVehicle类派生出自行车类CBicycle，添加属性：高度height

3)从CVehicle类派生出汽车类CMotocar，添加属性：座位数seat_num

4)从CBicycle和CMotocar派生出摩托车类CMotocycle

2、分别定义以上类的构造函数、输出函数display及其他函数（如需要）。

3、在主函数中定义各种类的对象，并测试之，通过对象调用display函数产生输出。

输入

第一行：最高速度 速度 重量 第二行：高度 第三行：座位数

输出

第一行：Vehicle: 第二行及以后各行：格式见Sample

#include <bits/stdc++.h>
using namespace std;
class CVehicle
{
protected:
    int max_speed;
    int speed;
    int weight;
public:
    virtual void display()
    {
        cout << "Vehicle:\n";
        cout << "max_speed:" << max_speed << '\n' << "speed:" << speed << '\n' << "weight:" << weight << '\n';
        cout << '\n';
    }
    CVehicle(int max_speed,int speed,int weight) 
        : max_speed(max_speed),speed(speed),weight(weight) 
    {}
};
class CBicycle : virtual public CVehicle
{
protected:
    int height;
public:
    CBicycle(int max_speed, int speed, int weight,int height)
        : CVehicle(max_speed, speed, weight),height(height)
    {}
    void display() override
    {
        cout << "Bicycle:\n";
        cout << "max_speed:" << max_speed << '\n' << "speed:" << speed << '\n' << "weight:" << weight << '\n';
        cout << "height:" << height << '\n';
        cout << '\n';
    }
};
class CMotocar : virtual public CVehicle
{
protected:
    int seat_num;
public:
    CMotocar(int max_speed, int speed, int weight, int seat_num)
        : CVehicle(max_speed, speed, weight), seat_num(seat_num)
    {}
    void display() override
    {
        cout << "Motocar:\n";
        cout << "max_speed:" << max_speed << '\n' << "speed:" << speed << '\n' << "weight:" << weight << '\n';
        cout << "seat_num:" << seat_num << '\n';
        cout << '\n';
    }
};
class CMotocycle : public CBicycle,public CMotocar
{
public:
    CMotocycle(int max_speed, int speed, int weight, int height, int seat_num)
        : CVehicle(max_speed, speed, weight), CBicycle(max_speed, speed, weight, height), CMotocar(max_speed, speed, weight, seat_num)
    {}
    void display() override
    {
        CVehicle::display();
        CBicycle::display();
        CMotocar::display();
        cout << "Motocycle:\n";
        cout << "max_speed:" << max_speed << '\n' << "speed:" << speed << '\n' << "weight:" << weight << '\n';
        cout << "height:" << height << '\n';
        cout << "seat_num:" << seat_num << '\n';
    }
};
int main()
{
    int max_speed, speed, weight, height, seat_num;
    cin >> max_speed >> speed >> weight >> height >> seat_num;
    CMotocycle cmo(max_speed, speed, weight, height, seat_num);
    cmo.display();
    return 0;
}

id:76】【20分】D. 商旅信用卡（多重继承）

时间限制1s

内存限制128MB

题目描述

某旅游网站（假设旅程网）和某银行推出旅游综合服务联名卡—旅程信用卡，兼具旅程会员卡和银行信用卡功能。

旅程会员卡，有会员卡号（int）、旅程积分（int），通过会员卡下订单，按订单金额累计旅程积分。

信用卡，有卡号（int）、姓名（string)、额度（int)、账单金额（float)、信用卡积分（int）。------请注意数据类型

信用卡消费金额m，若超额度，则不做操作；否则，账单金额+m，额度-m，信用卡积分按消费金额累加。

信用卡退款m，账单金额-m，信用卡积分减去退款金额。

通过旅程信用卡在旅程网下单，旅程积分和信用卡积分双重积分（即旅程积分和信用卡积分同时增加）。

旅程信用卡可以按      旅程积分：信用卡积分= 1：2    的比例将信用卡积分兑换为旅程积分。

初始假设信用卡积分、旅程积分、账单金额为0。

根据上述内容，定义旅程会员卡类、信用卡类，从两者派生出旅程信用卡类并定义三个类的构造函数和其它所需函数。

生成旅程信用卡对象，输入卡信息，调用对象成员函数完成旅程网下单、信用卡刷卡、信用卡退款、信用卡积分兑换为旅程积分等操作。

输入

第一行：输入旅程会员卡号 信用卡号 姓名 额度

第二行：测试次数n

第三行到第n+2行，每行：操作 金额或积分

o   m（旅程网下订单，订单金额m）

c   m（信用卡消费，消费金额m）

q   m (信用卡退款，退款金额m）

t    m（积分兑换，m信用卡积分兑换为旅程积分）

输出

输出所有操作后旅程信用卡的信息：

旅程号   旅程积分

信用卡号  姓名   账单金额   信用卡积分

#include <bits/stdc++.h>
using namespace std;
class TravelCard 
{
protected:
    int cardNumber;
    double points;
public:
    TravelCard(int cardNumber) 
        : cardNumber(cardNumber), points(0) 
    {}
    void order(int amount) 
    {
        points += amount;
    }
    double getPoints() 
    {
        return points;
    }
};

class CreditCard 
{
protected:
    int cardNumber;
    string name;
    double limit;
    double billAmount;
    double points;
public:
    CreditCard(int cardNumber, string name, double limit) 
        : cardNumber(cardNumber), name(name), limit(limit), billAmount(0), points(0) 
    {}
    void consume(double amount) 
    {
        if (amount <= limit) 
        {
            billAmount += amount;
            limit -= amount;
            points += amount;
        }
    }
    void refund(double amount) 
    {
        billAmount -= amount;
        points -= amount;
    }
    double getPoints() 
    {
        return points;
    }
};

class TravelCreditCard : public TravelCard, public CreditCard 
{
public:
    TravelCreditCard(int travelCardNumber, int creditCardNumber, string name, double limit) 
        : TravelCard(travelCardNumber), CreditCard(creditCardNumber, name, limit) 
    {}
    void order(double amount) 
    {
        TravelCard::order(amount);
        CreditCard::consume(amount);
    }
    void exchange(double amount) 
    {
        if (CreditCard::points >= amount)
        {
            CreditCard::points -= amount;
            TravelCard::points += amount / 2;
        }
    }
    void print() 
    {
        cout << TravelCard::cardNumber << " " << TravelCard::points << endl;
        cout << CreditCard::cardNumber << " " << CreditCard::name << " " << CreditCard::billAmount << " " << (int)CreditCard::points << endl;
    }
};

int main() 
{
    int travelCardNumber, creditCardNumber;
    double limit;
    string name;
    cin >> travelCardNumber >> creditCardNumber >> name >> limit;
    int n;
    TravelCreditCard card(travelCardNumber, creditCardNumber, name, limit);
    cin >> n;
    while (n--)
    {
        char operation;
        double amount;
        cin >> operation >> amount;
        switch (operation) 
        {
        case 'o':
            card.order(amount);
            break;
        case 'c':
            card.consume(amount);
            break;
        case 'q':
            card.refund(amount);
            break;
        case 't':
            card.exchange(amount);
            break;
        }
    }
    card.print();
    return 0;
}

 

#include <bits/stdc++.h>
using namespace std;
class CPeople{
	protected:
		char name[10];
		char id[20];
	public:
		CPeople(){	} 
		CPeople(char n[10],char i[20]){
			strcpy(name,n);
			strcpy(id,i);
		}		
};
class CInternetUser:public CPeople{
	protected:
		char password[20];
	public:
		void registerUser(char n[10],char i[20],char p[20]){
			strcpy(name,n);
			strcpy(id,i);
			strcpy(password,p); 
		}	
}; 
class CBankCustomer:public CPeople{
	protected:
		double bank_balance;	//银行余额 
	public:
		CBankCustomer(){
			
		}
		void openAccount(char n[10],char i[20]){
			strcpy(name,n);
			strcpy(id,i);
			bank_balance=0;
		}
		void deposit(double b){
			bank_balance+=b;
		}
		bool withdraw(double b){
			if(bank_balance-b>=0){
				bank_balance-=b;
				return 1;
			}
			else
				return 0;
		}
};
class CInternetBankCustomer:public CBankCustomer,public CInternetUser{
	protected:
		double Int_balance; 	//网上银行余额 
		double yesterday_balance;	//昨日余额 
		double today_earnings; //今日收益
		double today_interest; //今日万元收益率 
		double yesterday_interest;	//昨日万元收益率	 
	public:
		 CInternetBankCustomer(){
		 	Int_balance=0.00;
		 	yesterday_balance=0.00;
			today_earnings=0.00;
		 	today_interest=0.00;
		 	yesterday_interest=0.00;
		 }
		 bool deposit(double b){	//重写函数 
		 	if(bank_balance-b>=0){
		 		bank_balance-=b;
		 		Int_balance+=b;
				return 1; 
			 }
			 else 
			 	return 0;
		 }
		 bool withdraw(double b){	//重写函数 
			if(Int_balance-b>=0){
				Int_balance-=b;
				bank_balance+=b;
				return 1;
			}
			else
				return 0;
		}
		void setInterest(double i){			 
			yesterday_interest=today_interest;	//今天的收益率变成昨天的收益率 
			today_interest=i;				//输入的新收益率变成今天的收益率 
		}
		void calculateProfit(){
			today_earnings=yesterday_balance*0.0001*yesterday_interest;		//今天的收益=昨天的存款*昨天的收益率 
			Int_balance+=today_earnings; 			//今日新的存款=今日的存款+今天的收益 
			yesterday_balance=Int_balance;			//把今天的收益赋值给昨天的收益 
		}
		 void print(){
		 	cout<<"Name: "<<CBankCustomer::name<<" ID: "<<CBankCustomer::id<<endl;
		 	cout<<"Bank balance: "<<bank_balance<<endl;
		 	cout<<"Internet bank balance: "<<Int_balance<<endl;
		 }
		bool login(char i[20],char p[20]){
			return ((!strcmp(i,CInternetUser::id))&&(!strcmp(p,CInternetUser::password))) &&(!strcmp(CInternetUser::id,CBankCustomer::id)&&!strcmp(CInternetUser::name,CBankCustomer::name));
		} 	//先判断输入的id和密码是否与互联网用户的相同，同时从CBankCustomer继承的用户姓名和id要与从CInternetUser继承的相同
};
int main()
{
int t, no_of_days, i;
char i_xm[20], i_id[20], i_mm[20], b_xm[20], b_id[20], ib_id[20], ib_mm[20];
double money, interest;
char op_code;
//输入测试案例数t
     cin >> t;
     while (t--)
     {
//输入互联网用户注册时的用户名,id,登陆密码
        cin >> i_xm >> i_id >> i_mm;
//输入银行开户用户名,id
        cin >> b_xm >> b_id;
//输入互联网用户登陆时的id,登陆密码
        cin >> ib_id >> ib_mm;
  CInternetBankCustomer ib_user;
      ib_user.registerUser(i_xm, i_id, i_mm);
      ib_user.openAccount(b_xm, b_id);
      if (ib_user.login(ib_id, ib_mm) == 0)  //互联网用户登陆,若id与密码不符;以及银行开户姓名和id与互联网开户姓名和id不同
     {
         cout << "Password or ID incorrect" << endl;
         continue;
      }
//输入天数
      cin >> no_of_days;
      for (i=0; i < no_of_days; i++)
     {
      //输入操作代码, 金额, 当日万元收益
          cin >> op_code >> money >> interest;
          switch (op_code)
         {
            case 'S':  //从银行向互联网金融帐户存入
            case 's':
               if (ib_user.deposit(money) == 0)
               {
                  cout << "Bank balance not enough" << endl;
                  continue;
               }
               break;
          case 'T':  //从互联网金融转入银行帐户
          case 't':
              if (ib_user.withdraw(money) == 0)
             {
                 cout << "Internet bank balance not enough" << endl;
                 continue;
             }
             break;
          case 'D':  //直接向银行帐户存款
          case 'd':
               ib_user.CBankCustomer::deposit(money);
              break;
          case 'W':  //直接从银行帐户取款
           case 'w':
               if (ib_user.CBankCustomer::withdraw(money) == 0)
              {
                    cout << "Bank balance not enough" << endl;
                   continue;
              }
              break;
          default:
                cout << "Illegal input" << endl;
               continue;
         }
          ib_user.setInterest(interest);
          ib_user.calculateProfit();
          ib_user.print();
          cout<<endl;
      }
   }
}