某小型公司，主要有四类人员：经理、兼职技术人员、销售经理和兼职推销员。现在，需要存储这些人员的姓名、编号、级别、当月薪水，计算月薪总额并显示全部信息。要求： 1．其中，人员编号在生成人员信息时同时生成，每输入一个人员信息编号顺序加1。 2．程序对所有人员有提升级别的功能 3．月薪的计算方法是：经理拿固定月薪，兼职技术人员按工作小时数领取月薪，兼职推销员的报酬按该推销员当月销售额提成 ,销售经理既拿固定月薪也领取销售提成。 4．能按姓名或者编号显示、查找、增加、删除和保存各类人员的信息。

这是一个技术问题，我可以回答。这个问题需要使用编程语言来实现，可以使用面向对象的思想，定义一个人员类，包含姓名、编号、级别、月薪等属性和计算月薪的方法。然后定义经理类、兼职技术人员类、销售经理类和兼职推销员类，继承人员类，并重写计算月薪的方法。最后，可以使用列表或字典等数据结构来存储人员信息，并实现按姓名或编号查找、增加、删除和保存等功能。

相关问题

某小型公司，主要有四类人员：经理、兼职技术人员、销售经理和兼职推销员。现在，需要存储这些人员的姓名、编号、级别、当月薪水，计算月薪总额并显示全部信息。参考功能： 1) 人员编号在生成人员信息时同时生成，每输入一个人员信息编号顺序加1。 2) 程序对所有人员有提升级别的功能。 3) 月薪的计算方法是：经理拿固定月薪，兼职技术人员按工作小时数领取月薪，兼职推销员的报酬按该推销员当月销售额提成 ,销售经理既拿固定月薪也领取销售提成。 4) 能按姓名或者编号显示、查找、增加、删除和保存各类人员的信息。

这是一个比较复杂的问题，需要用到面向对象编程的知识。下面是一个简单的示例代码，供参考：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

// 员工类
class Employee {
public:
    Employee(string name, int level) : m_name(name), m_level(level) {
        m_id = ++s_idCounter;
    }

    virtual ~Employee() {}

    virtual void calcSalary() = 0; // 纯虚函数，需要在子类中实现

    int getId() const {
        return m_id;
    }

    int getLevel() const {
        return m_level;
    }

    string getName() const {
        return m_name;
    }

    int getSalary() const {
        return m_salary;
    }

protected:
    int m_id;
    string m_name;
    int m_level;
    int m_salary;

private:
    static int s_idCounter;
};

int Employee::s_idCounter = 0;

// 经理类
class Manager : public Employee {
public:
    Manager(string name, int level, int salary) : Employee(name, level), m_salary(salary) {}

    void calcSalary() {
        m_salary = m_salary;
    }

private:
    int m_salary;
};

// 兼职技术人员类
class PartTimeTech : public Employee {
public:
    PartTimeTech(string name, int level, int hours) : Employee(name, level), m_hours(hours) {}

    void calcSalary() {
        m_salary = m_hours * m_hourlyWage;
    }

private:
    int m_hours;
    static const int m_hourlyWage = 100;
};

const int PartTimeTech::m_hourlyWage;

// 兼职推销员类
class PartTimeSales : public Employee {
public:
    PartTimeSales(string name, int level, int sales) : Employee(name, level), m_sales(sales) {}

    void calcSalary() {
        m_salary = m_sales * m_commissionRate;
    }

private:
    int m_sales;
    static const double m_commissionRate;
};

const double PartTimeSales::m_commissionRate = 0.1;

// 销售经理类
class SalesManager : public Manager {
public:
    SalesManager(string name, int level, int salary, int sales) : Manager(name, level, salary), m_sales(sales) {}

    void calcSalary() {
        m_salary = Manager::m_salary + m_sales * m_commissionRate;
    }

private:
    int m_sales;
    static const double m_commissionRate;
};

const double SalesManager::m_commissionRate = 0.05;

// 公司类
class Company {
public:
    void addEmployee(Employee* employee) {
        m_employees.push_back(employee);
    }

    void removeEmployee(int id) {
        for (auto it = m_employees.begin(); it != m_employees.end(); ++it) {
            if ((*it)->getId() == id) {
                delete *it;
                m_employees.erase(it);
                break;
            }
        }
    }

    void updateEmployeeLevel(int id, int newLevel) {
        for (auto it = m_employees.begin(); it != m_employees.end(); ++it) {
            if ((*it)->getId() == id) {
                (*it)->m_level = newLevel;
                break;
            }
        }
    }

    void calcSalary() {
        for (auto employee : m_employees) {
            employee->calcSalary();
        }
    }

    void sortById() {
        sort(m_employees.begin(), m_employees.end(), [](Employee* a, Employee* b) {
            return a->getId() < b->getId();
        });
    }

    void sortByName() {
        sort(m_employees.begin(), m_employees.end(), [](Employee* a, Employee* b) {
            return a->getName() < b->getName();
        });
    }

    void printAll() const {
        for (auto employee : m_employees) {
            cout << "ID: " << employee->getId() << ", Name: " << employee->getName() 
                 << ", Level: " << employee->getLevel() << ", Salary: " << employee->getSalary() << endl;
        }
    }

private:
    vector<Employee*> m_employees;
};

int main() {
    Company company;

    // 添加员工
    company.addEmployee(new Manager("Amy", 1, 5000));
    company.addEmployee(new PartTimeTech("Bob", 2, 80));
    company.addEmployee(new PartTimeSales("Cathy", 3, 30000));
    company.addEmployee(new SalesManager("David", 4, 8000, 50000));

    // 计算月薪
    company.calcSalary();

    // 按编号排序并显示
    company.sortById();
    company.printAll();

    // 删除员工
    company.removeEmployee(2);

    // 修改员工级别
    company.updateEmployeeLevel(4, 5);

    // 按姓名排序并显示
    company.sortByName();
    company.printAll();

    return 0;
}

这个示例代码中，我们定义了一个员工类 `Employee`，并派生出了四个子类：经理类 `Manager`、兼职技术人员类 `PartTimeTech`、兼职推销员类 `PartTimeSales` 和销售经理类 `SalesManager`。每个子类实现了自己的月薪计算方法。我们还定义了一个公司类 `Company`，用于管理所有的员工，并提供了添加、删除、修改、计算月薪、排序等功能。在 `main` 函数中，我们创建了一些员工并添加到公司中，然后对公司进行一些操作，并最终打印所有员工的信息。

这只是一个示例代码，实际的实现要比这个复杂得多，需要考虑很多细节，比如员工编号的生成、查找员工、保存员工信息等等。但是这个示例代码可以帮助你理解如何用面向对象的思想来解决这个问题。