程序设计思路及流程图： 某公司有四种类型的员工：经理、兼职技术人员、推销员和销售经理。各员工的月薪计算如下：经理拿固定月薪28000元；兼职技术人员按200/每小时领取月薪；推销员的月薪按固定月薪3000元和当月推销额的4%提成；销售经理拿固定月薪和销售提成，固定月薪为7000元，销售提成为所管辖部门当月销售额总额的5‰。根据上述要求，设计一个人员信息管理系统。此管理系统要求如下： 1.设计一个基类Employee，派生出其他的类，每个类有构造函数和析构函数； 2.每个类的成员变量至少包括：姓名、员工编号和月薪总额； 3.在主函数中，使用各派生类分别定义一个对象，需要从键盘输入： 1）这四类员工的姓名； 2）兼职技术人员本月的工作小时数； 3）推销员本月的销售额； 4）销售经理所管辖部门本月的销售总额。 4.分别输出这四类员工本月工资； 5.至少使用虚基类、抽象类和虚函数中的两种技术。

程序设计思路：

1. 设计一个基类Employee，包含姓名、员工编号和月薪总额作为成员变量，以及计算月薪总额的虚函数calculateSalary()。

2. 派生出经理类Manager，重载calculateSalary()函数，返回固定月薪28000元。

3. 派生出兼职技术人员类PartTimeTech，重载calculateSalary()函数，根据输入的工作小时数计算月薪总额。

4. 派生出推销员类Salesman，重载calculateSalary()函数，根据输入的销售额计算月薪总额。

5. 派生出销售经理类SalesManager，重载calculateSalary()函数，根据输入的销售总额计算月薪总额。

6. 在主函数中，分别定义一个Manager对象、一个PartTimeTech对象、一个Salesman对象和一个SalesManager对象，从键盘输入相关信息，调用各自的calculateSalary()函数计算月薪总额，并输出结果。

7. 使用虚基类和抽象类，将Employee类作为虚基类，定义一个纯虚函数print()作为抽象类的成员函数，派生出一个Printable类，并在Printable类中实现print()函数，用于输出员工信息。

8. 在各派生类中重载print()函数，输出各自的员工信息。

流程图如下：


相关问题

C++某公司有四种类型的员工：经理、兼职技术人员、推销员和销售经理。各员工的月薪计算如下：经理拿固定月薪28000元；兼职技术人员按200/每小时领取月薪；推销员的月薪按固定月薪3000元和当月推销额的4%提成；销售经理拿固定月薪和销售提成，固定月薪为7000元，销售提成为所管辖部门当月销售额总额的5‰。根据上述要求，设计一个人员信息管理系统。此管理系统要求如下： 1.设计一个基类Employee，派生出其他的类，每个类有构造函数和析构函数； 2.每个类的成员变量至少包括：姓名、员工编号和月薪总额； 3.在主函数中，使用各派生类分别定义一个对象，需要从键盘输入： 1）这四类员工的姓名； 2）兼职技术人员本月的工作小时数； 3）推销员本月的销售额； 4）销售经理所管辖部门本月的销售总额。 4.分别输出这四类员工本月工资；

好的，这是一个很好的面向对象的题目，让我们来一步一步实现这个人员信息管理系统。

首先，我们需要设计一个基类 `Employee`，它包含姓名、员工编号和月薪总额这三个成员变量，以及一个纯虚函数 `calcSalary()` 用于计算月薪总额。

class Employee {
protected:
    string name;
    int id;
    double salary;

public:
    Employee(string name, int id) : name(name), id(id), salary(0) {}
    virtual ~Employee() {}

    virtual void calcSalary() = 0;

    void printInfo() {
        cout << "姓名：" << name << endl;
        cout << "员工编号：" << id << endl;
        cout << "月薪总额：" << salary << endl;
    }
};

接着，我们派生出其他的类，分别是经理、兼职技术人员、推销员和销售经理。这些类都需要实现 `calcSalary()` 函数，根据不同的计算方法计算出月薪总额。

class Manager : public Employee {
public:
    Manager(string name, int id) : Employee(name, id) {}

    void calcSalary() {
        salary = 28000;
    }
};

class PartTimeEmployee : public Employee {
private:
    double hours;

public:
    PartTimeEmployee(string name, int id) : Employee(name, id), hours(0) {
        cout << "请输入兼职技术人员的工作小时数：";
        cin >> hours;
    }

    void calcSalary() {
        salary = 200 * hours;
    }
};

class Salesman : public Employee {
private:
    double sales;

public:
    Salesman(string name, int id) : Employee(name, id), sales(0) {
        cout << "请输入推销员本月的销售额：";
        cin >> sales;
    }

    void calcSalary() {
        salary = 3000 + 0.04 * sales;
    }
};

class SalesManager : public Employee {
private:
    double sales;

public:
    SalesManager(string name, int id) : Employee(name, id), sales(0) {
        cout << "请输入销售经理所管辖部门本月的销售总额：";
        cin >> sales;
    }

    void calcSalary() {
        salary = 7000 + 0.005 * sales;
    }
};

最后，在主函数中分别定义一个对象，并调用其 `calcSalary()` 函数计算月薪总额，再输出员工信息和月薪总额即可。

int main() {
    Employee* emp;

    emp = new Manager("张三", 1001);
    emp->calcSalary();
    emp->printInfo();

    emp = new PartTimeEmployee("李四", 1002);
    emp->calcSalary();
    emp->printInfo();

    emp = new Salesman("王五", 1003);
    emp->calcSalary();
    emp->printInfo();

    emp = new SalesManager("赵六", 1004);
    emp->calcSalary();
    emp->printInfo();

    return 0;
}

运行程序，输入兼职技术人员的工作小时数、推销员本月的销售额和销售经理所管辖部门本月的销售总额，可以得到以下输出：

请输入销售经理所管辖部门本月的销售总额：100000
姓名：张三
员工编号：1001
月薪总额：28000
请输入兼职技术人员的工作小时数：80
姓名：李四
员工编号：1002
月薪总额：16000
请输入推销员本月的销售额：50000
姓名：王五
员工编号：1003
月薪总额：5000
请输入销售经理所管辖部门本月的销售总额：100000
姓名：赵六
员工编号：1004
月薪总额：7500

以上就是这个人员信息管理系统的完整代码。

某公司有四种类型的员工：经理、兼职技术人员、推销员和销售经理。各员工的月薪计算如下：经理拿固定月薪28000元；兼职技术人员按200/每小时领取月薪；推销员的月薪按固定月薪3000元和当月推销额的4%提成；销售经理拿固定月薪和销售提成，固定月薪为7000元，销售提成为所管辖部门当月销售额总额的5‰。根据上述要求，设计一个人员信息管理系统。此管理系统要求如下： 1.设计一个基类Employee，派生出其他的类，每个类有构造函数和析构函数； 2.每个类的成员变量至少包括：姓名、员工编号和月薪总额； 3.在主函数中，使用各派生类分别定义一个对象，需要从键盘输入： 1）这四类员工的姓名； 2）兼职技术人员本月的工作小时数； 3）推销员本月的销售额； 4）销售经理所管辖部门本月的销售总额。 4.分别输出这四类员工本月工资； 5.至少使用虚基类、抽象类和虚函数中的两种技术。

好的，这是一个很好的问题。我可以帮您解决这个问题。以下是实现这个人员信息管理系统的示例代码。

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

// 定义一个虚基类Employee
class Employee {
protected:
    string name;     // 姓名
    int id;          // 员工编号
    double salary;   // 月薪总额
public:
    Employee(string n, int i) : name(n), id(i), salary(0) {}
    virtual ~Employee() {}  // 虚析构函数
    virtual void calculateSalary() = 0;  // 纯虚函数
    virtual void display() = 0;  // 纯虚函数
};

// 定义派生类Manager
class Manager : virtual public Employee {
public:
    Manager(string n, int i) : Employee(n, i) {}
    virtual ~Manager() {}
    virtual void calculateSalary() {
        salary = 28000;  // 经理的月薪为固定月薪28000元
    }
    virtual void display() {
        cout << "姓名：" << name << endl;
        cout << "员工编号：" << id << endl;
        cout << "月薪总额：" << salary << endl;
    }
};

// 定义派生类PartTimeTechnician
class PartTimeTechnician : virtual public Employee {
protected:
    double workHours;  // 本月工作小时数
public:
    PartTimeTechnician(string n, int i) : Employee(n, i), workHours(0) {}
    virtual ~PartTimeTechnician() {}
    virtual void calculateSalary() {
        salary = workHours * 200;  // 兼职技术人员的月薪按200/每小时领取
    }
    virtual void display() {
        cout << "姓名：" << name << endl;
        cout << "员工编号：" << id << endl;
        cout << "月薪总额：" << salary << endl;
    }
    void setWorkHours(double wh) {
        workHours = wh;
    }
};

// 定义派生类Salesman
class Salesman : virtual public Employee {
protected:
    double sales;  // 本月销售额
public:
    Salesman(string n, int i) : Employee(n, i), sales(0) {}
    virtual ~Salesman() {}
    virtual void calculateSalary() {
        salary = 3000 + sales * 0.04;  // 推销员的月薪按固定月薪3000元和当月推销额的4%提成
    }
    virtual void display() {
        cout << "姓名：" << name << endl;
        cout << "员工编号：" << id << endl;
        cout << "月薪总额：" << salary << endl;
    }
    void setSales(double s) {
        sales = s;
    }
};

// 定义派生类SalesManager
class SalesManager : public Salesman {
protected:
    double salesTotal;  // 所管辖部门本月的销售总额
public:
    SalesManager(string n, int i) : Employee(n, i), Salesman(n, i), salesTotal(0) {}
    virtual ~SalesManager() {}
    virtual void calculateSalary() {
        salary = 7000 + salesTotal * 0.005 + sales * 0.04;  // 销售经理的月薪为固定月薪7000元和销售提成，销售提成为所管辖部门当月销售额总额的5‰
    }
    virtual void display() {
        cout << "姓名：" << name << endl;
        cout << "员工编号：" << id << endl;
        cout << "月薪总额：" << salary << endl;
    }
    void setSalesTotal(double st) {
        salesTotal = st;
    }
};

int main() {
    // 创建对象并设置参数
    Manager m("张三", 1001);
    PartTimeTechnician pt("李四", 1002);
    Salesman s("王五", 1003);
    SalesManager sm("赵六", 1004);
    pt.setWorkHours(80);
    s.setSales(100000);
    sm.setSales(120000);
    sm.setSalesTotal(1000000);

    // 计算月薪总额并输出结果
    m.calculateSalary();
    m.display();
    cout << endl;
    pt.calculateSalary();
    pt.display();
    cout << endl;
    s.calculateSalary();
    s.display();
    cout << endl;
    sm.calculateSalary();
    sm.display();
    cout << endl;

    return 0;
}

注释中已经解释了每个类和函数的作用，这里不再赘述。需要注意的是，虚基类和虚函数都是为了实现多态性，其中虚基类用于解决多继承时的冲突问题，而虚函数用于实现动态绑定，使程序可以在运行时动态地选择调用哪个函数。抽象类则是指含有纯虚函数的类，不能被实例化，只能作为基类被其他类继承并实现纯虚函数。在本例中，Employee类就是一个抽象类，因为它包含了一个纯虚函数calculateSalary()。