某公司财务需要开发一个计算雇员工资的程序。 该公司有3类员工。 工人 工资为每小时工资额乘当月工作时数再加上工龄工资； 销售人员 工资为每小时工资额乘当月工作时数加上销售额提成再加上工龄 工资，其中，销售额提成等于该销售人员当月售出商品金额的1%； 管理人员 工资为基本工资再加上工龄工资。 请用面向对象方法分析、设计这个程序，并用C++语言写出完整的程序。 要求设计人员基类，派生工人类，销售人员类和管理人员类， 举例： 员工工号：键盘输入 员工类型：键盘输入 姓名：键盘输入 参加工作时间：键盘输入 工人工资： 每小时工资额：宏定义80元/小时 月工作时数：键盘输入 工龄工资：第一年50元/月（宏定义），以后每年以20%递增，比如1978年参加工作，1979年为50+50*0.2=60元 月总工资 = 每小时工资额*月工作时数+工龄工资 输出：工号、姓名，员工类型，月工作时数、总工资 要求： 可以同时输入输出多位员工信息

分析：

根据题目要求，需要设计一个员工类作为基类，派生出工人类、销售人员类、管理人员类，每个派生类需要实现自己的工资计算方法。同时，需要从键盘输入员工的信息，计算出员工的月总工资，并输出员工的信息。

设计：

首先，我们设计一个员工类作为基类，包含员工的基本信息（员工工号、姓名、参加工作时间）以及计算月总工资的虚函数。然后，派生出工人类、销售人员类、管理人员类，分别实现自己的月总工资计算方法。最后，从键盘输入员工的信息，计算出员工的月总工资，并输出员工的信息。

代码如下：

相关问题

c++设计某公司财务部需要开发一个计算雇员工资的程序，该公司有3类员工，员工工资计算方法如下：（1）工人工资：每小时工资额（通过成员函数设定）乘以当月工作时数（通过成员函数设定），再加上工龄工资。（2）销售员工资：每小时工资额（通过成员函数设定）乘以当月工作时数（通过成员函数设定），加上销售额提成，再加上工龄工资，其中销售额提成等于该销售员当月售出的商品金额（通过成员函数设定）的1%。（3）管理人员工资：基本工资1000元，再加上工龄工资。 其中，工龄工资指雇员在该公司工作，工龄每满一年，月工资就增加35元，请用面向对象方法分析计设计这个程序。（使用继承与派生原则）

这个程序可以使用面向对象方法进行设计，使用继承与派生原则可以实现代码的复用，提高代码的可维护性和可扩展性。具体实现如下：

首先，定义一个基类 Employee，该类包含以下成员变量和成员函数：

class Employee {
protected:
    string name;          // 姓名
    int age;              // 年龄
    int yearsOfWork;      // 在公司工作的年数
    double hourlyWage;    // 每小时工资额
    double monthlyHours;  // 当月工作时数
public:
    Employee(string name, int age, double hourlyWage, double monthlyHours, int yearsOfWork);
    virtual double calculateSalary() = 0;  // 计算工资的纯虚函数
};

其中，构造函数用于初始化成员变量，calculateSalary() 是一个纯虚函数，用于在派生类中实现计算工资的具体方法。

然后，定义三个派生类：Worker、Salesman 和 Manager，分别对应三种不同的员工类型。

Worker 类的定义如下：

class Worker : public Employee {
private:
    double workingAgeWage;  // 工龄工资
public:
    Worker(string name, int age, double hourlyWage, double monthlyHours, int yearsOfWork);
    virtual double calculateSalary();
};

其中，workingAgeWage 是工龄工资，calculateSalary() 函数的实现如下：

double Worker::calculateSalary() {
    return hourlyWage * monthlyHours + workingAgeWage;
}

Salesman 类的定义如下：

class Salesman : public Employee {
private:
    double salesAmount;     // 销售额
    double workingAgeWage;  // 工龄工资
public:
    Salesman(string name, int age, double hourlyWage, double monthlyHours, int yearsOfWork, double salesAmount);
    virtual double calculateSalary();
};

其中，salesAmount 是销售额，calculateSalary() 函数的实现如下：

double Salesman::calculateSalary() {
    return hourlyWage * monthlyHours + salesAmount * 0.01 + workingAgeWage;
}

Manager 类的定义如下：

class Manager : public Employee {
public:
    Manager(string name, int age, int yearsOfWork);
    virtual double calculateSalary();
};

其中，Manager 类没有 hourlyWage 和 monthlyHours 这两个成员变量，因为它的工资是由基本工资和工龄工资组成的。calculateSalary() 函数的实现如下：

double Manager::calculateSalary() {
    return 1000 + yearsOfWork * 35;
}

最后，我们需要在程序中创建对象并调用 calculateSalary() 函数来计算工资。例如：

int main() {
    Employee* employee1 = new Worker("张三", 30, 20, 160, 2);
    Employee* employee2 = new Salesman("李四", 25, 15, 160, 1, 10000);
    Employee* employee3 = new Manager("王五", 40, 10);

    cout << employee1->calculateSalary() << endl;
    cout << employee2->calculateSalary() << endl;
    cout << employee3->calculateSalary() << endl;

    delete employee1;
    delete employee2;
    delete employee3;

    return 0;
}

上述代码中，我们创建了三个不同类型的 Employee 对象，分别调用它们的 calculateSalary() 函数来计算工资。注意，由于 Employee 类中的 calculateSalary() 函数是一个纯虚函数，因此不能创建 Employee 类的对象，只能创建它的派生类的对象。同时，由于使用了动态内存分配，需要在程序结束前将对象释放掉。

某公司的雇员分为以下若干类 Employee ：这是所有员工总的父类，属性：员工的姓名,员工的生日月份。方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100 元。 SalariedEmployee ：Employee 的子类，拿固定工资的员工。属性：月薪 HourlyEmployee ：Employee 的子类，按小时拿工资的员工，每月工作超出160 小时的部分按照1.5 倍工资发放。属性：每小时的工资、每月工作的小时数 SalesEmployee ：Employee 的子类，销售人员，工资由月销售额和提成率决定。属性：月销售额、提成率 定义一个类Company，在main方法，把若干各种类型的员工放在一个Employee 数组里，并单元出数组中每个员工当月的工资。

以下是代码实现：

import java.util.Scanner;

public class Company {
    public static void main(String[] args) {
        Employee[] employees = new Employee[4];
        employees[0] = new SalariedEmployee("Tom", 10000);
        employees[1] = new HourlyEmployee("Jerry", 100, 180);
        employees[2] = new SalesEmployee("Bob", 5000, 0.05);
        employees[3] = new Employee("Alice", 7);

        for (Employee employee : employees) {
            System.out.println(employee.getName() + "'s salary of this month is " + employee.getSalary(7));
        }
    }
}

class Employee {
    private String name;
    private int birthMonth;

    Employee(String name, int birthMonth) {
        this.name = name;
        this.birthMonth = birthMonth;
    }

    String getName() {
        return name;
    }

    int getBirthMonth() {
        return birthMonth;
    }

    double getSalary(int month) {
        double salary = 0.0;
        if (month == birthMonth) {
            salary += 100;
        }
        return salary;
    }
}

class SalariedEmployee extends Employee {
    private double monthlySalary;

    SalariedEmployee(String name, double monthlySalary) {
        super(name, 0);
        this.monthlySalary = monthlySalary;
    }

    @Override
    double getSalary(int month) {
        double salary = super.getSalary(month);
        return salary + monthlySalary;
    }
}

class HourlyEmployee extends Employee {
    private double hourlyWage;
    private int monthlyWorkHours;

    HourlyEmployee(String name, double hourlyWage, int monthlyWorkHours) {
        super(name, 0);
        this.hourlyWage = hourlyWage;
        this.monthlyWorkHours = monthlyWorkHours;
    }

    @Override
    double getSalary(int month) {
        double salary = super.getSalary(month);
        if (monthlyWorkHours > 160) {
            salary += (monthlyWorkHours - 160) * hourlyWage * 1.5 + 160 * hourlyWage;
        } else {
            salary += monthlyWorkHours * hourlyWage;
        }
        return salary;
    }
}

class SalesEmployee extends Employee {
    private double monthlySales;
    private double commissionRate;

    SalesEmployee(String name, double monthlySales, double commissionRate) {
        super(name, 0);
        this.monthlySales = monthlySales;
        this.commissionRate = commissionRate;
    }

    @Override
    double getSalary(int month) {
        double salary = super.getSalary(month);
        salary += monthlySales * commissionRate;
        return salary;
    }
}

在本例中，定义了一个父类Employee和三个子类SalariedEmployee、HourlyEmployee和SalesEmployee。每个子类继承了父类的属性和方法，并且根据不同的员工类型，重写了getSalary方法来计算每个员工的工资。主函数中，定义了一个Employee数组，分别放置了不同类型的员工，并且打印出了每个员工当月的工资。