南京邮电大学通达学院2023c++实验报告（三）

题目

实验题目1

某公司财务部需要开发一个计算雇员工资的程序。该公司有3类员工，工资计算方式如下：
（1）工人工资：每小时工资额（通过成员函数设定）乘以当月工作时数（通过成员函数设定），再加上工龄工资。
（2）销售员工资：每小时工资额（通过成员函数设定）乘以当月工作时数（通过成员函数设定），加上销售额提成，再加上工龄工资；其中销售额提成等于该销售员当月售出商品金额（通过成员函数设定）的1%。
（3）管理人员工资：基本工资1000元，再加上工龄工资。
其中，工龄工资指雇员在该公司工作的工龄每增加一年，月工资就增加35元。
请用面向对象方法分析、设计这个程序，并用C++语言写出完整程序，要求对象通过外部设置参数的方式初始化（如：Worker Zhang(“zhang wei”, 8)），输出三种雇员的姓名、工资。
提示：
① 可创建“雇员”为基类，工人、销售员、管理人员为其派生类；
② 涉及到的基类属性：姓名、工龄；

实验题目2

下图为一个多重继承的类继承关系示意图，各类的主要成员已有说明，请编写体现该继承关系的程序，并定义教师对象、学生对象、研究生对象、在职研究生对象，输出他们的信息。
（1）关于数据成员：
数据类Data：成员name保存姓名；
教师类Teacher：增加成员sal保存工资；
学生类Student：增加成员id保存学号;
研究生类 Postgrad：增加成员 dn保存系别;
教师中的在职研究生类Tpost：不另外定义成员。
（2）关于成员函数：
在各类中定义输出所有数据成员的函数void print()。

答案

第一题

代码

#include<iostream>
using namespace std;
class employee {
protected:
	string name;
	int worked_time;
public:
	double Payforbase() {
		return worked_time * 35;
	}
	void SetWorkedTime(int wt) {
		worked_time = wt;
	}
};
class Worker :public employee {
private:
	double WorkTime;
	double pay_per_time;
public:
	Worker() {}
	Worker(int wt,string n) {
		worked_time = wt;
		name = n;
	}
	Worker(int wt, double wt2, double ppt,string n) {
		worked_time = wt;
		WorkTime = wt2;
		pay_per_time = ppt;
		name = n;
	}
	double pay() {
		return pay_per_time * WorkTime + Payforbase();
	}
	void SetWorkTime(double wt) {
		WorkTime = wt;
	}
	void Setpaypettime(double ppt) {
		pay_per_time = ppt;
	}
};
class salesPerson :public employee {
private:
	double WorkTime;
	double pay_per_time;
	double sales;
public:
	salesPerson() {}
	salesPerson(int wt, string n) {
		worked_time = wt;
		name = n;
	}
	salesPerson(int wt, double Wt, double ppt, double s,string n) {
		worked_time = wt;
		pay_per_time = ppt;
		sales = s;
		WorkTime = Wt;
		name = n;
	}
	double pay() {
		return pay_per_time * WorkTime + Payforbase()+sales*0.01;
	}
	void SetWorkTime(double wt) {
		WorkTime = wt;
	}
	void Setpaypettime(double ppt) {
		pay_per_time = ppt;
	}
	void SetSales(double s) {
		sales = s;
	}
};
class administrators :public employee {
public:
	administrators() {}
	administrators(int wt,string n) {
		worked_time = wt;
		name = n;
	}
	double pay() {
		return worked_time * 35 + 1000;
	}
};
int main() {
	Worker w(8,"张三");
	salesPerson s(10,"李四");
	administrators a(20,"王五");
	w.Setpaypettime(100);
	w.SetWorkTime(200);
	cout << "张三的工资是" << w.pay();
	s.Setpaypettime(150);
	s.SetWorkTime(100);
	s.SetSales(88888);
	cout << "\n李四的工资是" << s.pay();
	cout << "\n王五的工资是" << a.pay();
}

设计思路

这个程序定义了三个员工类，分别是员工、销售员和管理员。它们都继承自员工类，但是因为各自的工资计算方法不同，所以重写了pay()函数。

员工类有基本工资Payforbase()，计算方法是基本工资=工作时间*35元/小时。子类工资计算方法是由基本工资和额外的奖励或提成组成的。

销售员类的工资计算方法是基本工资+每小时工作的支付+销售额的0.01倍（即提成）。

管理员类的工资计算方法是基本工资（工作时间*35元/小时）+1000元。

在主函数main()中，构造3个员工的对象，并分别设置其属性值（工作时间，工资等），最后分别输出他们的工资（调用对应类中的pay()函数）。

第二题

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

class Data {
protected:
    string name;
public:
    virtual void print() = 0;
};

class Teacher : public Data {
protected:
    int sal;
public:
    Teacher(string n, int s) {
        name = n;
        sal = s;
    }
    void print() {
        cout << "Name: " << name << ", Salary: " << sal << endl;
    }
};

class Student : public Data {
protected:
    int id;
public:
    Student(string n, int i) {
        name = n;
        id = i;
    }
    void print() {
        cout << "Name: " << name << ", Student ID: " << id << endl;
    }
};

class Postgrad : public Student {
protected:
    string dn;
public:
    Postgrad(string n, int i, string d) : Student(n, i) {
        dn = d;
    }
    void print() {
        cout << "Name: " << name << ", Student ID: " << id << ", Department: " << dn << endl;
    }
};

class Tpost : public Teacher {
public:
    Tpost(string n, int s) : Teacher(n, s) {}
    void print() {
        cout << "Name: " << name << ", Salary: " << sal << endl;
    }
};

int main() {
    Teacher t("Teacher1", 5000);
    Student s("Student1", 10001);
    Postgrad pg("Postgrad1", 20001, "Department1");
    Tpost tp("TPost1", 6000);

    t.print();
    s.print();
    pg.print();
    tp.print();

    return 0;
}

设计思路

1. 定义一个抽象类 Data 基类，其中包含一个虚函数 print()，用于输出数据成员信息，该类的数据成员为 name，表示姓名。

2. 定义教师类 Teacher，继承 Data 基类，并增加一个数据成员 sal，表示教师的工资，构造函数中传入 name 和工资；重载 print() 函数，输出 name 和 sal。

3. 定义学生类 Student，继承 Data 基类，并增加一个数据成员 id，表示学生的学号，构造函数中传入 name 和学号；重载 print() 函数，输出 name 和 id。

4. 定义研究生类 Postgrad，继承 Student 类，并增加一个数据成员 dn，表示研究生所在的系别。构造函数中传入 name、id 和 dn；重载 print() 函数，输出 name、id 和 dn。

5. 定义在职研究生类 Tpost，继承 Teacher 类，重载 print() 函数，输出 name 和 sal。

6. 在 main 函数中，分别定义教师对象、学生对象、研究生对象以及在职研究生对象，传入相应的参数，然后调用 print() 函数输出对象的信息。

整个程序的设计思路很清晰，每个类都只关注自己的独有数据成员和功能，并与父类进行了正确地继承和扩展，这使得整个代码结构简洁和易于理解。