C++小案例-职工管理系统

更多教程笔记请查看我的上一篇文章：点击跳转

此系统采用分文件编写，使用类与对象，纯虚函数，多态，继承实现，数据存储在.txt文本中

• 主文件
• 抽象类
• 老板类
• 老板类实现
• 员工类
• 员工类实现
• 经理类
• 经理类实现
• 管理类
• 管理类实现

main.cpp文件代码:

// C++小案例-职工管理系统
#include <iostream>
#include <stdlib.h>
//引入存放着管理类的.h文件
#include "workerManger.cpp"
#include "employee.cpp"
#include "manager.cpp"
#include "boss.cpp"
using namespace std;
int main()
{
    //测试代码
    //创建一个人的类指针
    // Worker *worker = NULL;
    // //将指针指向普通员工
    // worker = new Employee(1, "zs", 1);
    // //通过父类指针调用子类函数,输出岗位的具体职责
    // worker->showInfo();
    // //用完后要释放
    // delete worker;

    // //再用父类的指针指向经理的子类
    // worker = new Manager(2, "lisi", 2);
    // //调用经理的岗位具体描述
    // worker->showInfo();
    // delete worker;

    // //再用父类的指针指向老板的子类
    // worker = new Boss(3, "wangwu", 3);
    // worker->showInfo();
    // delete worker;

    //实例化管理者对象
    WorkerManager wm;
    //用来存储用户的选项
    char choice = 0;
    while (true)
    {
        //调用管理类的成员函数
        //展示菜单的成员函数
        wm.Show_Menu();
        //提示用户输入
        cout << "Please enter your choice:  " << endl;
        //接收用户的选项
        cin >> choice;
        switch (choice)
        {
        case '0': //退出系统
            wm.ExitSystem();
            break;
        case '1': //增加职工
                  //调用定义好的添加函数
            wm.Add_Emp();
            break;
        case '2': //显示职工
            wm.Show_Emp();
            break;
        case '3': //删除职工
            /*
            {         //测试,
                      // case语句里要加{}代码块才能定义变量
                int ret = wm.IsExist(5);
                if (ret != -1)
                {
                    //输出职工存在
                    cout << "Elempty yes" << endl;
                }
                else
                {
                    //职工不存在
                    cout << "No Elempty" << endl;
                }
                break;
            }
            */
            wm.Del_Emp();
            break;
        case '4': //修改职工
            wm.Mod_Emp();
            break;
        case '5': //查找职工
            wm.Find_Emp();
            break;
        case '6': //排序职工
            wm.Sort_Emp();
            break;
        case '7': //清空文档
            wm.Clean_File();
            break;
        default:
            //输入错误直接清屏
            system("cls");
            break;
        }
    }
    return 0;
}

worker.h文件代码:

//此文件专门用来存放抽象类
#pragma once
#include <iostream>
using namespace std;
#include <string>
//职工抽象类
class Worker
{
public:
    //显示个人信息,纯虚函数
    virtual void showInfo() = 0;
    //获取岗位名称
    virtual string getDeptName() = 0;
    //职工编号
    int m_Id;
    //职工姓名
    string m_Name;
    //部门编号
    int m_DeptId;
};

boss.h文件代码:

//此文件用来存放老板类
//此文件专门用来存放经理的类定义
#pragma once
#include <iostream>
using namespace std;
//因为要有一个继承的操作,所以要包含父类的头文件
#include "worker.h"

//在.h文件里面写类的定义的时候只需要写声明就好
//具体实现在.cpp文件里面
//老板类
class Boss : public Worker
{
public:
    //注意:在父类里函数可以在后面写=0
    //但是在子类的函数定义后面不能写=0,因为要在其他文件中类外写具体实现

    //构造函数
    Boss(int id, string name, int dId);

    //显示个人信息,纯虚函数
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();
};

boss.cpp文件代码:

//此文件用来实现老板类的成员函数的具体实现
#include "boss.h"

//构造函数
Boss::Boss(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}
//显示个人信息
void Boss::showInfo()
{
    cout << "Employee_id: " << this->m_Id
         << "\tEmployee_Name:" << this->m_Name
         << "\tEmployee_DId:" << this->getDeptName()
         << "\tjob description: Manage all affairs of the company" << endl;
}
//获取岗位名称
string Boss::getDeptName()
{
    //返回老板的岗位名称
    //不转string类型也行,因为会默认隐式转换
    return string("Boss");
}

employee.h文件代码:

//普通职工文件
#pragma once
#include <iostream>
#include "worker.h"
using namespace std;
//用普通职工类去继承在.h头文件里定义好的抽象类
class Employee : public Worker
{
public:
    //构造函数
    //形参分别是职工的编号,职工的名字,所属部门的编号
    Employee(int id, string name, int dId);
    //重写父类中的纯虚函数
    //显示个人信息
    virtual void showInfo();
    //获取岗位名称
    virtual string getDeptName();
};

employee.cpp文件代码:

//这个文件主要用于.h文件中的职工类的函数的具体实现
#include "employee.h"

//类外实现函数的具体实现
//构造函数
Employee::Employee(int id, string name, int dId)
{
    //这里的m_Id属性是从work.h文件里继承过来的
    this->m_Id = id;
    // this的特性是谁调用this,this就指向谁
    //也就是说当创建了一个Employee职工类的对象的时候,如果对象
    //调用了构造函数传参,那么this就指向那个对象本身
    this->m_Name = name;
    this->m_DeptId = dId;
}
//重写父类中的纯虚函数
//显示个人信息
void Employee::showInfo()
{
    cout << "Employee_id: " << this->m_Id
         << "\tEmployee_Name:" << this->m_Name
         << "\tEmployee_DId:" << this->getDeptName()
         << "\tjob description: Complete the tasks assigned above" << endl;
    //因为岗位并不是用数字表示的,所以要通过函数返回具体的岗位
    //后一个参数是岗位职责,也就是岗位描述,完成上面安排的任务
}
//获取岗位名称
string Employee::getDeptName()
{
    //返回一个普通职工的岗位,因为默认返回字符串是char *类型,所以要转换成string类型
    return string("employee");
}

manager.h文件代码:

//此文件专门用来存放经理的类定义
#pragma once
#include <iostream>
using namespace std;
//因为要有一个继承的操作,所以要包含父类的头文件
#include "worker.h"

//在.h文件里面写类的定义的时候只需要写声明就好
//具体实现在.cpp文件里面
//经理类
class Manager : public Worker
{
public:
    //构造函数
    Manager(int id, string name, int dId);

    //其实在继承中子类不需要在函数前面加上virtual关键字变成纯虚函数
    //因为父类当中有纯虚函数,子类继承过来就自动是纯虚函数了
    //不过写了也没啥影响,但是在其他文件中通过类外写具体函数实现的时候
    //要记得把virtual关键字去掉

    //显示个人信息,纯虚函数
    virtual void showInfo();

    //获取岗位名称
    virtual string getDeptName();
};

manager.cpp文件代码:

//此文件用来写经理类的成员函数具体实现
#include "manager.h"

//构造函数
Manager::Manager(int id, string name, int dId)
{
    this->m_Id = id;
    this->m_Name = name;
    this->m_DeptId = dId;
}
//显示个人信息
void Manager::showInfo()
{
    cout << "Employee_id: " << this->m_Id
         << "\tEmployee_Name:" << this->m_Name
         << "\tEmployee_DId:" << this->getDeptName()
         << "\tjob description: Complete tasks assigned by boss and distribute tasks to ordinary employees" << endl;
}
//获取岗位名称
string Manager::getDeptName()
{
    //返回经理的岗位名称
    //不转string类型也行,因为会默认隐式转换
    return string("manager");
}

workerManager.h文件代码:

//这个文件专门用来存放管理类
//#pragma once可以防止头文件重复包含
#pragma once
#include <iostream>
#include <algorithm>
using namespace std;
//因为要定义一个职工数组,所以需要引入worker.h头文件
#include "worker.h"
#include "employee.h"
#include "manager.h"
#include "boss.h"
//文件操作的头文件
#include <fstream>
//定义一个宏用来保存文件路径
#define FILENAME "class_03/empFile.txt"

//管理类
class WorkerManager
{
public:
    //构造函数
    WorkerManager();

    //展示菜单的函数
    void Show_Menu();

    //退出功能
    void ExitSystem();

    //记录职工的人数
    int m_EmpNum;

    //职工数组指针
    Worker **m_EmpArray;

    //添加职工的函数声明,在.cpp文件中会做具体实现
    void Add_Emp();

    //保存文件,在.cpp文件中会做具体实现
    void save();

    //判断文件是否为空
    bool m_FileIsEmpty;

    //统计文件中的人数
    int get_EmpNum();

    //初始化员工
    void init_Emp();

    //显示职工
    void Show_Emp();

    //删除职工
    void Del_Emp();

    //判断职工是否存在,如果存在则返回职工所在数组中的位置,不存在返回-1
    int IsExist(int id);

    //修改职工
    void Mod_Emp();

    //查找职工
    void Find_Emp();

    //按照职工的编号排序
    void Sort_Emp();

    //清空文件
    void Clean_File();

    //快速排序升序
    void quick_sort1(int l, int r);

    //快速排序降序
    void quick_sort2(int l, int r);

    //析构函数
    ~WorkerManager();
};

workerManager.cpp文件代码:

//此文件用来引入另一个.h的头文件,那里面存放着管理类
//并且在引入了父类之后需要在这个文件里,也就是类外文件写函数的具体实现
#include "workerManager.h"

//调用.h文件里面的管理类的构造函数
WorkerManager::WorkerManager()
{
    //读文件
    ifstream ifs;
    ifs.open(FILENAME, ios::in);
    //在构造函数时，在检测文件是否存在前对文件是否为空初始化为false
    this->m_FileIsEmpty = false;
    //判断文件是否打开成功
    if (!(ifs.is_open()))
    {
        //文件不存在
        // cout << "No!" << endl;

        //初始化属性
        //也就是一创建对象就调用这个构造函数
        //将记录的人数初始化为0
        this->m_EmpNum = 0;

        //初始化数组指针
        this->m_EmpArray = NULL;

        //初始化文件是否为空
        this->m_FileIsEmpty = true;
        ifs.close();
        return;
    }
    //判断文件存在但是数据为空
    char ch;
    //通过ifs对象函数不停的往字符里面读数据
    ifs >> ch;
    //如果读到EOF就表示读完了
    //先读一个,然后用eof判断是不是已经没了，读掉一个就没了，说明是空的
    if (ifs.eof())
    {
        //文件为空
        // cout << "No NULL!" << endl;
        //初始化属性
        //也就是一创建对象就调用这个构造函数
        //将记录的人数初始化为0
        this->m_EmpNum = 0;

        //初始化数组指针
        this->m_EmpArray = NULL;

        //初始化文件是否为空,如果文件不存在或者文件没有数据就置为true
        this->m_FileIsEmpty = true;
        ifs.close();
        return;
    }
    //当文件存在,并且也有记录数据,则调用定义好的函数统计文件中的数据
    int num = this->get_EmpNum();
    //输出职工人数
    // cout << "EmpNum: " << num << endl;
    //更新职工的人数为文件中的数据
    this->m_EmpNum = num;

    //创建一个职工数组,数组的长度是文件中的数据的大小
    this->m_EmpArray = new Worker *[this->m_EmpNum];
    //将文件中的数据,存到数组中
    this->init_Emp();

    //测试代码
    // for (int i = 0; i < this->m_EmpNum; i++)
    // {
    //     //输出文件存入到数组中的数据
    //     cout << "id: " << this->m_EmpArray[i]->m_Id
    //          << " name: " << this->m_EmpArray[i]->m_Name
    //          << " DepId: " << this->m_EmpArray[i]->m_DeptId << endl;
    // }
}

//展示菜单
void WorkerManager::Show_Menu()
{
    cout << "***********************************************************" << endl;
    //欢迎使用职工管理系统!
    cout << "******** Welcome to the staff management system! **********" << endl;
    // 0.退出管理程序
    cout << "************* 0. Exit the management program **************" << endl;
    // 1.增加职工信息
    cout << "************* 1. Increase employee information ************" << endl;
    // 2.显示职工信息
    cout << "************* 2. Display employee information *************" << endl;
    // 3.删除离职职工
    cout << "************* 3. Delete the former employees **************" << endl;
    // 4.修改职工信息
    cout << "************* 4. Modify employee information **************" << endl;
    // 5.查找职工信息
    cout << "************* 5. Look up employee information *************" << endl;
    // 6.按照编号排序
    cout << "******************** 6. Sort by number ********************" << endl;
    // 7.清空所有文档
    cout << "******************** 7. Clear all documents ***************" << endl;
    cout << "***********************************************************" << endl;
    cout << endl;
}

//退出系统的具体实现
void WorkerManager::ExitSystem()
{
    //提示用户选择了退出
    cout << "Welcome to use next time" << endl;
    system("pause");
    //退出程序
    exit(0);
}

//添加职工的具体实现
void WorkerManager::Add_Emp()
{
    //提示用户请输入要添加的职工的数量
    cout << "Please enter the number of employees to be added" << endl;
    //保存用户的输入数量
    int addNum = 0;
    cin >> addNum;
    if (addNum > 0)
    {
        //如果大于0的话就添加
        //计算添加新空间的大小,新空间大小=原来的记录的人数+新增的人数
        int newSize = this->m_EmpNum + addNum;
        //开辟新空间,这是一个动态数组,通过动态的在堆区开辟数据
        //返回的是指向这块内存的一级指针,要用二级指针接收它
        Worker **newSpace = new Worker *[newSize];
        //将原来空间下的数据,拷贝到新空间下
        if (this->m_EmpArray != NULL)
        {
            //判断如果原来数组中有数据则把原来数组中的数据全部拷贝到新开辟的数组中
            for (int i = 0; i < this->m_EmpNum; i++)
            {
                newSpace[i] = this->m_EmpArray[i];
            }
        }
        //批量添加新数据
        for (int i = 0; i < addNum; i++)
        {
            //职工编号
            int id;
            //职工姓名
            string name;
            //部门选择
            int dSelect;
            //提示用户请输入第i+1个新职工的编号
            cout << "Please enter the first " << i + 1 << " Number of new employee:" << endl;
            cin >> id;
            //提示用户请输入第i+1个新职工的姓名
            cout << "Please enter the first " << i + 1 << " Name of new employee:" << endl;
            cin >> name;

            //提示用户请输入第i+1个新职工的部门
            cout << "Please enter the first " << i + 1 << " dSelect of new employee:" << endl;
            cout << "1.General Trade Union" << endl;
            cout << "2.Manager" << endl;
            cout << "3.Boss" << endl;
            cin >> dSelect;
            Worker *worker = NULL;
            switch (dSelect)
            {
            case 1:
                /* 如果为1则表示输入是一个普通员工 */
                worker = new Employee(id, name, 1);
                break;
            case 2:
                /* 如果为1则表示输入是一个普通员工 */
                worker = new Manager(id, name, 1);
                break;
            case 3:
                /* 如果为1则表示输入是一个普通员工 */
                worker = new Boss(id, name, 1);
                break;
            default:
                break;
            }
            //将创建职工的指针,保存到数组中
            //通过+i,在数组中找到要添加的人的具体位置
            //也就是如果要加一个人,那么就加0,那个人就被加在0号位置,如果要加第二个人
            //那么+i就是加1,那个人就被加在2号位置
            newSpace[this->m_EmpNum + i] = worker;
        }
        //添加完成,释放原有的空间,这是释放数组的写法
        delete[] this->m_EmpArray;
        //更改新空间的指向
        //因为原来的空间被释放了后m_EmpArray指针就可以指向新的数组空间
        this->m_EmpArray = newSpace;
        //更新新的职工人数
        // newSize是在最上面定义的新空间的大小
        // newSpace相当于把原来的复制了一份再加上新增的数据，所以可以释放掉原来的
        this->m_EmpNum = newSize;
        //更新职工不为空的情况标志
        this->m_FileIsEmpty = false;

        //提示添加成功
        cout << "success add: " << addNum << " new Empwork!" << endl;

        //成功添加后保存到文件中
        this->save();
    }
    else
    {
        //如果小于0就提示无法添加
        cout << "NO" << endl;
    }
    //当添加完成了提示用户按任意键清屏
    system("pause");
    system("cls");
}

//保存文件
void WorkerManager::save()
{
    ofstream ofs;
    //用输出的方式来打开文件---也就是写文件
    ofs.open(FILENAME, ios::out);
    //将每个人的数据写入到文件中
    for (int i = 0; i < this->m_EmpNum; i++)
    {
        //利用ofs对数组里面每一行的数据通过文件写入
        ofs << this->m_EmpArray[i]->m_Id << " "
            << this->m_EmpArray[i]->m_Name << " "
            << this->m_EmpArray[i]->m_DeptId << endl;
    }
    //关闭文件
    ofs.close();
}

//统计文件中的人数
int WorkerManager::get_EmpNum()
{
    ifstream ifs;
    //打开文件--读
    ifs.open(FILENAME, ios::in);
    int id;
    string name;
    int dId;
    int num = 0;
    //将一行内所有数据全部读到手
    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        //统计人数变量
        num++;
    }
    //将统计到的人数返回
    return num;
}

//类外实现初始化员工
void WorkerManager::init_Emp()
{
    ifstream ifs;
    //以读的方式打开
    ifs.open(FILENAME, ios::in);
    int id;
    string name;
    int dId;
    //用来存放数组的下标
    int index = 0;
    while (ifs >> id && ifs >> name && ifs >> dId)
    {
        //创建一个父类指针
        Worker *worker = NULL;
        //普通员工
        if (dId == 1)
        {
            //通过父类指针调用子类函数,创建一个普通员工
            worker = new Employee(id, name, dId);
        }
        else if (dId == 2) //经理
        {
            worker = new Manager(id, name, dId);
        }
        else
        {
            //老板
            worker = new Boss(id, name, dId);
        }
        //第一次将第一个人放入数组中第0号位置,第二次++将第二个人放到第1号位置
        this->m_EmpArray[index] = worker;
        index++;
    }
    //关闭文件
    ifs.close();
}

//显示职工
void WorkerManager::Show_Emp()
{
    //判断文件是否存在
    if (this->m_FileIsEmpty)
    {
        //如果为true即为不存在
        cout << "No NULL" << endl;
    }
    else
    {
        for (int i = 0; i < m_EmpNum; i++)
        {
            //利用多态调用程序接口
            this->m_EmpArray[i]->showInfo();
        }
    }
    //按任意键后清屏
    system("pause");
    system("cls");
}

//删除职工
void WorkerManager::Del_Emp()
{
    //判断文件是否存在
    if (this->m_FileIsEmpty)
    {
        cout << "No NULL" << endl;
    }
    else
    {
        //按照职工编号删除,提示用户输入要删除的数据的编号
        cout << "please cin delete Id:" << endl;
        int id = 0;
        cin >> id;
        //判断要删除的职工的id存不存在
        int index = this->IsExist(id);
        //说明职工存在,并且要删除掉index位置上的职工
        if (index != -1)
        {
            //数组删除本质上就是数据往前移
            //数组从0开始所以数组的总长度要减一
            for (int i = index; i < this->m_EmpNum - 1; i++)
            {
                //数据前移
                this->m_EmpArray[i] = this->m_EmpArray[i + 1];
            }
            //更新数组中记录的人员个数
            this->m_EmpNum--;
            //同步更新到文件中
            this->save();
            cout << "delete success!" << endl;
        }
        else
        {
            //如果没有找到这个人就提示删除失败
            cout << "delete error!" << endl;
        }
    }
    system("pause");
    system("cls");
}

//判断职工是否存在,如果存在则返回职工所在数组中的位置,不存在返回-1
int WorkerManager::IsExist(int id)
{
    int index = -1;
    for (int i = 0; i < this->m_EmpNum; i++)
    {
        //遍历数组判断如果数组中员工的id等于传入的id则找到了这个职工
        if (this->m_EmpArray[i]->m_Id == id)
        {
            index = i;
            break;
        }
    }
    return index;
}

//修改职工
void WorkerManager::Mod_Emp()
{
    //判断是否为空
    if (this->m_FileIsEmpty)
    {
        //文件不存在
        cout << "NO NULL" << endl;
    }
    else
    {
        //请输入要修改的职工的编号
        cout << "please cin edit id: " << endl;
        int id;
        cin >> id;
        //判断要修改的职工编号是否存在
        int ret = this->IsExist(id);
        if (ret != -1)
        {
            //查找到编号的职工

            //释放数组当中原来的数据,为了让新的数据替换
            delete this->m_EmpArray[ret];
            int newId = 0;
            string newName = "";
            int dSelect = 0;
            //提示用户查找到了职工,让用户输入新的职工号
            cout << "find: " << id << "emelpty edit new Number:" << endl;
            cin >> newId;
            //提示用户查找到了职工,让用户输入新的职工姓名
            cout << "find emelpty edit new name:" << endl;
            cin >> newName;
            //提示用户查找到了职工,让用户输入新的职工岗位
            cout << "find emelpty edit new dSelect:" << endl;
            cout << "1.General Trade Union" << endl;
            cout << "2.Manager" << endl;
            cout << "3.Boss" << endl;
            cin >> dSelect;
            //创建一个父类的指针
            Worker *worker = NULL;
            switch (dSelect)
            {
            case 1:
                worker = new Employee(newId, newName, dSelect);
                break;
            case 2:
                worker = new Manager(newId, newName, dSelect);
                break;
            case 3:
                worker = new Boss(newId, newName, dSelect);
                break;

            default:
                break;
            }
            //更新数据 到数组中
            this->m_EmpArray[ret] = worker;
            //修改成功
            cout << "edit success!" << endl;
            //保存到文件中
            this->save();
        }
        else
        {
            //修改失败
            cout << "edit error" << endl;
        }
    }
    system("pause");
    system("cls");
}

//查找职工
void WorkerManager::Find_Emp()
{
    //文件不存在
    if (this->m_FileIsEmpty)
    {
        cout << "NO NULL" << endl;
    }
    else
    {
        //请输入查找的方式
        cout << "please cin find function: " << endl;
        //按照职工的编号查找
        cout << "1.elempty Id: " << endl;
        //按照职工的姓名查找
        cout << "2.elempty name: " << endl;
        int select = 0;
        cin >> select;
        if (select == 1)
        {
            //按照编号查找
            int id;
            //请输入职工的编号
            cout << "please cin elempty id: " << endl;
            cin >> id;
            //判断这个职工的编号是否存在
            int ret = IsExist(id);
            if (ret != -1)
            {
                //找到职工
                cout << "find success!" << endl;
                //将找到的职工显示
                this->m_EmpArray[ret]->showInfo();
            }
            else
            {
                //如果找不到就提示查找失败
                cout << "find error" << endl;
            }
        }
        else if (select == 2)
        {
            //按照姓名查找
            string name;
            cout << "please cin find name" << endl;
            cin >> name;
            //判断是否查找成功的标志
            //默认未找到
            bool flag = false;

            for (int i = 0; i < m_EmpNum; i++)
            {
                if (this->m_EmpArray[i]->m_Name == name)
                {
                    //查找成功,输出找到的那个人的Id号
                    cout << "find success elempty Id:"
                         << this->m_EmpArray[i]->m_Id
                         << "elempty All:" << endl;
                    //如果进来了这个循环就表示找到了这个人
                    flag = true;

                    //调用显示信息的接口,输出关于那个编号的人的所有信息
                    this->m_EmpArray[i]->showInfo();
                }
            }
            //如果循环结束后依然等于false就表示查找失败
            if (flag == false)
            {
                //查找失败
                cout << "find error" << endl;
            }
        }
        else
        {
            //输入错误
            cout << "cin error" << endl;
        }
    }
    system("pause");
    system("cls");
}

//按照职工的编号排序
void WorkerManager::Sort_Emp()
{
    //文件不存在
    if (this->m_FileIsEmpty)
    {
        cout << "No NULL" << endl;
        system("pause");
        system("cls");
    }
    else
    {
        //提示用户请选择排序的方式
        cout << "please Sort function:" << endl;
        //按照职工的编号进行升序排序
        cout << "1.an elempty Id a<b" << endl;
        //按照职工的编号进行降序排序
        cout << "2.an elempty Id a>b" << endl;
        //接受用户的选择
        int select = 0;
        cin >> select;
        // //选择排序算法
        // for (int i = 0; i < m_EmpNum; i++)
        // {
        //     //声明一个最小值或者最大值的下标
        //     int minOrMax = i;
        //     for (int j = i + 1; j < this->m_EmpNum; j++)
        //     {
        //         //升序
        //         if (select == 1)
        //         {
        //             if (this->m_EmpArray[minOrMax]->m_Id > this->m_EmpArray[j]->m_Id)
        //             {
        //                 minOrMax = j;
        //             }
        //         }
        //         else //降序
        //         {
        //             if (this->m_EmpArray[minOrMax]->m_Id < this->m_EmpArray[j]->m_Id)
        //             {
        //                 minOrMax = j;
        //             }
        //         }
        //     }
        //     //判断一开始认定的最小值或最大值 是否是 计算的最小值或最大值 如果不是 交换数据
        //     if (i != minOrMax)
        //     {
        //         Worker *temp = this->m_EmpArray[i];
        //         this->m_EmpArray[i] = this->m_EmpArray[minOrMax];
        //         this->m_EmpArray[minOrMax] = temp;
        //     }
        // }
        //快速排序
        if (select == 1)
        {
            this->quick_sort1(0, this->m_EmpNum - 1);
        }
        else
        {
            this->quick_sort2(0, this->m_EmpNum - 1);
        }
        //排序成功,输出排序后的结果
        cout << "Sort success! Sort All: " << endl;
        //将排序后的结果保存到文件中
        this->save();
        //输出排序后的结果
        this->Show_Emp();
        //在Show_Emp()输出函数中已经做了清屏的操作,所以在下面就不用写了
    }
}
//快速排序类外实现
void WorkerManager::quick_sort1(int l, int r)
{
    if (l >= r)
    {
        return;
    }
    int i = l - 1, j = r + 1;
    Worker *x = this->m_EmpArray[l + (r - l) / 2];
    while (i < j)
    {
        do
        {
            ++i;
        } while (this->m_EmpArray[i]->m_Id < x->m_Id);
        do
        {
            --j;
        } while (this->m_EmpArray[j]->m_Id > x->m_Id);
        if (i < j)
        {
            swap(this->m_EmpArray[i], this->m_EmpArray[j]);
        }
    }
    quick_sort1(l, j);
    quick_sort1(j + 1, r);
}

//快速排序类外实现
void WorkerManager::quick_sort2(int l, int r)
{
    if (l >= r)
    {
        return;
    }
    int i = l - 1, j = r + 1;
    Worker *x = this->m_EmpArray[l + (r - l) / 2];
    while (i < j)
    {
        do
        {
            ++i;
        } while (this->m_EmpArray[i]->m_Id > x->m_Id);
        do
        {
            --j;
        } while (this->m_EmpArray[j]->m_Id < x->m_Id);
        if (i < j)
        {
            swap(this->m_EmpArray[i], this->m_EmpArray[j]);
        }
    }
    quick_sort2(l, j);
    quick_sort2(j + 1, r);
}

//清空文件
void WorkerManager::Clean_File()
{
    //提示用户是否确定清空
    cout << "confirm clear?" << endl;
    cout << "1.Yes" << endl;
    cout << "2.No" << endl;
    //接收用户的输入
    int select = 0;
    cin >> select;
    if (select == 1)
    {
        //清空文件,在ofs构造函数中就指定文件路径
        // trunc代表删除文件后重新创建
        ofstream ofs(FILENAME, ios::trunc);
        ofs.close();

        //清空数组
        if (this->m_EmpArray != NULL)
        {
            //删除堆区的每个职工对象
            for (int i = 0; i < this->m_EmpNum; i++)
            {
                delete this->m_EmpArray[i];
                this->m_EmpArray[i] = NULL;
            }
            //删除堆区的数组指针
            delete[] this->m_EmpArray;
            //删除完后将指针置为空
            this->m_EmpArray = NULL;
            //将表示数组长度的变量等于0
            this->m_EmpNum = 0;
            //将判断文件是否为空的标识为true;
            this->m_FileIsEmpty = true;
        }
        cout << "clear success!" << endl;
    }
    system("pause");
    system("cls");
}

//类外实现析构函数
WorkerManager::~WorkerManager()
{
    //对象销毁前将创建的数组释放掉
    //再将数组指针置为空
    //判断如果数组不为空
    if (this->m_EmpArray != NULL)
    {
        //要先清空内部的数组元素，再清空数组,因为数组元素也是new出来的
        for (int i = 0; i < this->m_EmpNum; i++)
        {
            //将数组当中的每一个元素都置为空
            if (this->m_EmpArray[i] != NULL)
            {
                delete this->m_EmpArray[i];
            }
        }
        delete[] this->m_EmpArray;
        this->m_EmpArray = NULL;
    }
}