假定要为某个公司编写雇员工资支付程序，这个公司有各种类型的雇员（employee），不同类型的雇员按不同的方式支付工资（都是整数）： （1）经理（manager）——每月获得一份固定的工资 （2）销售人员（salesman）——在基本工资的基础上每月还有销售提成 （3）一般工人（worker）——则按他每月工作的天数计算工资 在employee中提供函数getsalary()计算每个雇员一个月的工资，并在子类中重写。 在main函数中构造employee的三个变量，分别指向manager、salesman、worker的对象，调用getsalary函数，输出三个对象的工资

### 回答1：
好的，以下是回复：

这道题目要求编写一个雇员工资支付程序，这个公司有三种不同类型的雇员：经理、销售人员和一般工人。不同类型的雇员按不同的方式支付工资，需要在每个子类中重写getsalary函数来计算每个雇员一个月的工资。在main函数中，需要构造三个变量，分别指向manager、salesman、worker的对象，并调用getsalary函数，输出三个对象的工资。

### 回答2：
针对上述要求，可以提供以下思路：

1. 创建一个 Employee 类作为基类，其中包含一个虚函数 getsalary()，子类可以根据自己的薪资计算方式重写该函数。
2. 创建 Manager、Salesman 和 Worker 三个子类，分别继承 Employee 类，并重写 getsalary() 函数，计算不同类型雇员的薪资。
3. 在 main 函数中，分别创建 Manager、Salesman 和 Worker 对象，用基类指针指向它们，并调用 getsalary() 函数，输出薪资结果。

以下是具体的实现：

#include<iostream>
using namespace std;

class Employee {
public:
    virtual int getsalary() { return 0; } // 虚函数
};

class Manager : public Employee { // 经理类
public:
    virtual int getsalary() { return 10000; } // 每月固定获得 10000 元
};

class Salesman : public Employee { // 销售员类
public:
    virtual int getsalary() { return 2000 + sales * 0.1; } // 基本工资 2000，加上销售提成
    void setsales(int s) { sales = s; } // 设置销售额
private:
    int sales; // 销售额
};

class Worker : public Employee { // 普通工人类
public:
    virtual int getsalary() { return days * 100; } // 每日工资 100 元，根据工作天数计算
    void setdays(int d) { days = d; } // 设置工作天数
private:
    int days; // 工作天数
};

int main() {
    Employee* emp1 = new Manager(); // 经理对象
    Employee* emp2 = new Salesman(); // 销售员对象
    Employee* emp3 = new Worker(); // 工人对象

    // 设置销售额和工作天数
    dynamic_cast<Salesman*>(emp2)->setsales(5000);
    dynamic_cast<Worker*>(emp3)->setdays(20);

    // 输出薪资
    cout << "Manager's Salary: " << emp1->getsalary() << endl;
    cout << "Salesman's Salary: " << emp2->getsalary() << endl;
    cout << "Worker's Salary: " << emp3->getsalary() << endl;

    // 释放内存
    delete emp1;
    delete emp2;
    delete emp3;

    return 0;
}

通过动态类型转换 dynamic_cast，我们可以将基类指针转换为实际的子类指针，然后调用子类的成员函数 setsales 和 setdays 进行赋值，最后输出三个对象的薪资。

这个程序的设计是比较简单的，但是它有一个问题：就是没有在基类中定义类型成员变量。因为不同类型的员工工资方法不同，因此才会采用虚函数来实现多态。但是，为了更加清晰地区分不同类型的员工，最好在基类中定义一个类型成员变量，用来表示员工的类型，这样在调用 getsalary() 函数的时候就可以根据员工类型来判断，从而选择相应的计算方式。

### 回答3：
该公司雇员的不同类型和支付方式，可以使用继承关系来实现。首先定义一个抽象类Employee，包含一个纯虚函数getSalary()，用于计算各种类型的员工工资。然后继承该类分别实现Manager、Salesman和Worker三个子类，在子类中重写getSalary()方法。

Employee类的定义如下：

class Employee{
public:
virtual int getSalary() = 0;
};

Manager类的定义如下：

class Manager:public Employee{
public:
Manager(int salary){
this->salary = salary; //设置经理的固定工资
}
int getSalary(){ //重写getSalary()方法
return salary;
}
private:
int salary;
};

Salesman类的定义如下：

class Salesman:public Employee{
public:
Salesman(int salary, int sales){
this->salary = salary; //设置基本工资
this->sales = sales; //设置销售额
}
int getSalary(){ //重写getSalary()方法
return salary + sales * 0.1;
}
private:
int salary;
int sales;
};

Worker类的定义如下：

class Worker:public Employee{
public:
Worker(int day){
this->day = day; //设置工作天数
}
int getSalary(){ //重写getSalary()方法
return day * 100;
}
private:
int day;
};

在main函数中，构造三个不同类型的雇员对象，调用它们的getSalary()方法，输出每个员工的工资。

int main(){
Manager manager(5000); //经理，设置5000元的固定工资
Salesman salesman(3000, 20000); //销售员，设置3000元的基本工资和20000元的销售额
Worker worker(20); //一般工人，设置20天的工作天数

cout << "经理的工资：" << manager.getSalary() << "元" << endl;
cout << "销售员的工资：" << salesman.getSalary() << "元" << endl;
cout << "工人的工资：" << worker.getSalary() << "元" << endl;

return 0;
}

输出结果如下：

经理的工资：5000元
销售员的工资：5000元
工人的工资：2000元

说明经理和销售员得到的工资都超过了基本工资，而工人得到的工资只有月工作天数乘以100元。这个程序可以灵活应对不同类型雇员的支付方式。