要为某个公司编写雇员( n个雇员)支付月工资，这个公司有各种类型的雇员（Employee），不同类型的雇员按不同的方式支付工资

。为了实现这个功能，我们可以先定义一个基类 Employee，然后派生出各种类型的雇员类，如 HourlyEmployee（按小时计费的雇员）、SalariedEmployee（按月薪计费的雇员）、CommissionEmployee（按销售提成计费的雇员）等等。

在基类中定义一个纯虚函数 getSalary()，每个派生类必须实现这个函数以计算自己的工资。然后在主程序中，我们可以创建一个 Employee 类型的数组，存储所有的雇员对象，并依次调用它们的 getSalary() 函数，计算出每个雇员的工资并输出。

以下是具体的代码实现：

#include <iostream>
using namespace std;

class Employee {
public:
    virtual double getSalary() = 0; // 纯虚函数，必须在派生类中实现
};

class HourlyEmployee : public Employee {
private:
    double wage; // 每小时工资
    double hours; // 工作小时数
public:
    HourlyEmployee(double w, double h) : wage(w), hours(h) {}
    double getSalary() { return wage * hours; }
};

class SalariedEmployee : public Employee {
private:
    double salary; // 月薪
public:
    SalariedEmployee(double s) : salary(s) {}
    double getSalary() { return salary; }
};

class CommissionEmployee : public Employee {
private:
    double sales; // 销售额
    double rate; // 提成比例
public:
    CommissionEmployee(double s, double r) : sales(s), rate(r) {}
    double getSalary() { return sales * rate; }
};

int main() {
    const int n = 3; // 雇员数量
    Employee* employees[n]; // 雇员数组
    employees[0] = new HourlyEmployee(10, 160); // 创建 HourlyEmployee 对象
    employees[1] = new SalariedEmployee(5000); // 创建 SalariedEmployee 对象
    employees[2] = new CommissionEmployee(10000, 0.1); // 创建 CommissionEmployee 对象
    double total = 0; // 总工资
    for (int i = 0; i < n; i++) {
        total += employees[i]->getSalary(); // 调用虚函数计算工资
    }
    cout << "Total salary: " << total << endl; // 输出总工资
    for (int i = 0; i < n; i++) {
        delete employees[i]; // 释放内存
    }
    return 0;
}

以上代码中，我们通过创建 HourlyEmployee、SalariedEmployee 和 CommissionEmployee 对象来模拟不同类型的雇员，并使用一个 Employee 类型的数组存储它们。在计算总工资时，我们依次调用每个雇员对象的 getSalary() 函数，这里使用了虚函数的特性，能够根据对象的实际类型动态调用对应的函数。最后，我们释放掉所有的雇员对象，避免内存泄漏。