基于C++实现的职工信息管理系统

调用命令的cpp文件

Main.cpp

#include <iostream>  
#include "Operation.h"  
using namespace std;  
  
int main()  
{  
    Operation Action;  
  
    while (true)  
    {  
        Action.ShowMenu();  
          
        int Step = 0;  
        cout << "请输入需要操作的步骤：";  
        cin >> Step;  
  
        switch (Step)  
        {  
        case 0:  
            Action.ExitOperation(); // 退出程序  
            break;  
        case 1:  
            Action.AddMember(); // 添加职工信息  
            break;  
        case 2:  
            Action.ShowAllInf(); // 显示职工信息  
            break;  
        case 3:  
            Action.DeleteMember(); // 删除职工信息  
            break;  
        case 4:  
            Action.ModifyInf(); // 修改职工信息  
            break;  
        case 5:  
            Action.FindMember(); // 查找职工信息  
            break;  
        case 6:  
            Action.SortMember(); // 按需要进行排序  
            break;  
        case 7:  
            Action.ClearData(); // 清空文档中所有信息  
            break;  
        default:  
            break;  
        }  
        system("pause");  
        system("cls");  
    }  
}  

Main函数的作用只是调用命令。

实现对职工的各项操作的类

Operation.h

#pragma once  
  
#include "Worker.h"  
#include "Employee.h"  
#include "Manager.h"  
#include "Boss.h"  
#include <iostream>  
#include <fstream>  
#include <string>  
using namespace std;  
  
class Operation  
{  
private:  
    int WorkerNumber;  
    Worker** MemberRecord;  
    bool FileState;  
public:  
    // 初始化操作：1-判断文件的状态(空文件/文件正常/无文件)；2-读取文件中的信息至内存中  
    Operation();  
    void InitWorkerInf(); // 初始时将文本中的信息读入数组中  
  
    void ShowMenu(); // 显示菜单  
  
    void ExitOperation(); // 退出操作  
  
    // 添加成员的步骤：1-添加新成员；2-修改信息后需要将信息保存  
    void AddMember(); // 添加新成员  
    void SaveInf(); // 职工信息的保存  
      
    void ShowAllInf(); // 显示职工信息  
  
    // 删除职工的步骤：1-找到职工的位置；2-根据职工的位置判断职工是否存在并且给予删除  
    int IsExist(); // 判断员工是否存在并且返回员工的位置  
    void DeleteMember(); // 根据职工的位置判断职工是否存在并且给予删除  
  
    // 修改员工信息的步骤：1-查找特定员工在数组中的位置；2-修改员工信息  
    void ModifyInf(); // 修改员工信息  
      
    int FindMember(); // 查找指定职工并显示  
  
    void SortMember(); // 对所有员工进行排序（从小到大排序）  
  
    void ClearData(); // 清空文档的所有信息（文件变为空文件+人数为0+数据数组为空）  
  
    ~Operation();  
};  

Operation.cpp

#include "Operation.h"  
  
Operation::Operation()  
{  
    this->MemberRecord = nullptr; // 初始化数据数组位空  
    this->WorkerNumber = 0; // 初始化初始人数为0  
  
    ifstream ifs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::in);  
    if (!ifs.is_open())  
    {  
        cout << "文件打开失败！" << endl;  
        this->FileState = 0; // 文件未打开  
        ifs.close(); // 文件打开失败因此关闭文件流  
        return;  
    }  
  
    char ch;  
    ifs >> ch; // 先读取一个字符后判断文件指针是否在末尾就知道文件是否为空文件  
    if (ifs.eof())  
    {  
        FileState = false; // 文件为空文件  
    }  
    else  
    {  
        FileState = true; // 文件非空且存在  
    }  
    ifs.close(); // 判断文件数据是否非空后，关闭文件流  
  
    this->InitWorkerInf(); // 将文件的信息读取到内存当中  
}  
  
void Operation::ShowMenu()  
{  
    cout << "********************************************" << endl;  
    cout << "********* 欢迎使用职工管理系统！ **********" << endl;  
    cout << "************* 0.退出管理程序 *************" << endl;  
    cout << "************* 1.增加职工信息 *************" << endl;  
    cout << "************* 2.显示职工信息 *************" << endl;  
    cout << "************* 3.删除离职职工 *************" << endl;  
    cout << "************* 4.修改职工信息 *************" << endl;  
    cout << "************* 5.查找职工信息 *************" << endl;  
    cout << "************* 6.按照编号排序 *************" << endl;  
    cout << "************* 7.清空所有文档 *************" << endl;  
    cout << "********************************************" << endl;  
    cout << endl;  
}  
  
void Operation::ExitOperation()  
{  
    int IsExitOperation = 0;  
    cout << "是否退出程序？(1：是；0：否)：";  
    cin >> IsExitOperation;  
    if (IsExitOperation == 1)  
    {  
        cout << "退出程序成功." << endl;  
        exit(0);  
    }  
}  
  
void Operation::AddMember()  
{  
    Worker** NewMember = nullptr;  
    Worker* Object = nullptr;  
    int IncreasedNumber = 0;  
  
    cout << "请输入新添加工作人员的总人数：";  
    cin >> IncreasedNumber;  
  
    NewMember = new Worker*[this->WorkerNumber + IncreasedNumber]; // 申请足够的存储空间  
  
    if(this->WorkerNumber != 0) // 将已存在的人员移入新数组中  
    {  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            NewMember[i] = MemberRecord[i];  
        }  
    }  
    for (int i = this->WorkerNumber; i < this->WorkerNumber + IncreasedNumber; i++)  
    {  
        int PositionChoice = 0;  
        cout << "请输入工作人员的职位(1:Boss;2:Manager;3:Employee)：";  
        cin >> PositionChoice;  
  
        string name;  
        cout << "请输入职工姓名：";  
        cin >> name;  
  
        int ID = 0;  
        cout << "请输入职工的ID：";  
        cin >> ID;  
  
        for (int j = 0; j < i - 1; j++)  
        {  
            if (NewMember[j]->ID == ID)  
            {  
                cout << "输入ID重复" << endl;  
                return;  
            }  
        }  
          
        switch (PositionChoice) // 根据职位进行相应的初始化  
        {  
        case 1:  
            Object = new Boss(ID, name, PositionChoice);  
            break;  
        case 2:  
            Object = new Manager(ID, name, PositionChoice);  
            break;  
        case 3:  
            Object = new Employee(ID, name, PositionChoice);  
            break;  
        default:  
            break;  
        }  
  
        NewMember[i] = Object; // 将单个职工的数据信息并入总数据信息中  
    }  
    this->MemberRecord = NewMember; // 当前员工数据数组更新  
    this->WorkerNumber += IncreasedNumber; // 当前员工数量更新  
    this->SaveInf(); // 保存信息  
}  
  
void Operation::SaveInf()  
{  
    ofstream ofs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::out);  
    if (!ofs.is_open())  
    {  
        cout << "文件打开失败！" << endl;  
        return;  
    }  
    for (int i = 0; i < this->WorkerNumber; i++)  
    {  
        ofs << MemberRecord[i]->ID << " " << MemberRecord[i]->name << " " << MemberRecord[i]->Position << endl;  
    }  
    ofs.close(); // 关闭文件流  
}  
  
void Operation::InitWorkerInf()  
{  
    ifstream ifs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::in);  
  
    int num = 0;  
    int ID;  
    string name;  
    int Position;  
  
    //1:Boss;2:Manager;3:Employee  
    ifs.seekg(0, ios::beg);  
    while (ifs >> ID && ifs >> name && ifs >> Position)  
    {  
        num++; // 记录原文件中的成员个数  
    }  
    ifs.close();  
  
    this->WorkerNumber = num;  
    MemberRecord = new Worker*[this->WorkerNumber];  
  
    int index = 0;  
    ifs.open("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::in);  
    ifs.seekg(0, ios::beg);  
    while (ifs >> ID && ifs >> name && ifs >> Position)  
    {  
        Worker* Object = nullptr;  
  
        switch (Position)  
        {  
        case 1:  
            Object = new Boss(ID, name, Position);  
            break;  
        case 2:  
            Object = new Manager(ID, name, Position);  
            break;  
        case 3:  
            Object = new Employee(ID, name, Position);  
            break;  
        default:  
            break;  
        }  
  
        MemberRecord[index] = Object;  
        index++;  
    }  
}  
  
void Operation::ShowAllInf()  
{  
    if (this->FileState != false)  
    {  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            this->MemberRecord[i]->ShowInf(); // 使用多态显示每一个职工的信息  
        }  
    }  
    else  
    {  
        cout << "显示失败，原因：空文件或者文件打开失败！" << endl;  
    }  
}  
  
int Operation::IsExist()  
{  
    int ID = 0;  
    cout << "请输入职工的ID：";  
    cin >> ID;  
  
    for (int i = 0; i < this->WorkerNumber; i++)  
    {  
        if (MemberRecord[i]->ID == ID)  
        {  
            return i;  
        }  
    }  
    return -1;  
}  
  
void Operation::DeleteMember()  
{  
    int Order = this->IsExist(); // 获取目标员工的在数组中的序号  
    if (Order == -1)  
    {  
        cout << "删除失败，查无此人" << endl;  
        return;  
    }  
  
    int ID = this->MemberRecord[Order]->ID;  
  
    delete MemberRecord[Order];  
  
    for (int i = Order; i < this->WorkerNumber - 1; i++)  
    {  
        this->MemberRecord[i] = this->MemberRecord[i + 1];  
    }  
  
    Worker** temp = new Worker*[this->WorkerNumber - 1];  
    for (int i = 0; i < this->WorkerNumber - 1; i++)  
    {  
        temp[i] = this->MemberRecord[i];  
    }  
  
    for (int i = 0; i < this->WorkerNumber; i++) // 清空就内存区域  
    {  
        delete this->MemberRecord[i];  
    }  
  
    this->MemberRecord = temp; // 更新员工数据数组  
    this->WorkerNumber--; // 删除员工需更新员工人数  
    cout << "ID为" << ID << "的员工被删除成功" << endl;  
}  
  
void Operation::ModifyInf()  
{  
    int Order = this->FindMember();  
    if (Order == -1)  
    {  
        return; // 查无此人  
    }  
  
    delete MemberRecord[Order]; // 释放旧数据的存储空间  
  
    string name;  
    int ID;  
    int Position;  
    Worker* Object;  
  
    Local:cout << "请输入员工的姓名：";  
    cin >> name;  
  
    cout << "请输入员工的ID";  
    cin >> ID;  
  
    cout << "请输入员工的职位(1:Boss;2:Manager;3:Employee):";  
    cin >> Position;  
  
    switch (Position)  
    {  
    case 1:  
        Object = new Boss(ID, name, Position);  
        break;  
    case 2:  
        Object = new Manager(ID, name, Position);  
        break;  
    case 3:  
        Object = new Employee(ID, name, Position);  
        break;  
    default:  
        cout << "输入无效" << endl;  
        goto Local;  
        break;  
    }  
  
    this->MemberRecord[Order] = Object; // 存储新数据  
    cout << "信息修改成功" << endl;  
}  
  
int Operation::FindMember()  
{  
    bool OperationChoice = 0;  
    cout << "请输入查找的条件(ID:0;name:1)：";  
    cin >> OperationChoice;  
  
    if (OperationChoice == 0)  
    {  
        int ID = 0;  
        cout << "请输入目标职工的ID：";  
        cin >> ID;  
  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            if (this->MemberRecord[i]->ID == ID)  
            {  
                this->MemberRecord[i]->ShowInf();  
                return i;  
            }  
        }  
    }  
    else if(OperationChoice == 1)  
    {  
        string name;  
        cout << "请输入目标职工的姓名：";  
        cin >> name;  
  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            if (this->MemberRecord[i]->name == name)  
            {  
                this->MemberRecord[i]->ShowInf();  
                return i;  
            }  
        }  
    }  
    else  
    {  
        cout << "查无此人" << endl;  
        return -1;  
    }  
    return -1;  
}  
  
void Operation::SortMember()  
{  
    Worker* temp;  
  
    bool OperationChoice = 0;  
    cout << "请输入排序的依据(0:ID;1:name):";  
    cin >> OperationChoice;  
  
    bool SortDirection = 0;  
    cout << "请输入排序方向(min->max:0;max->min:1)：";  
    cin >> SortDirection;  
  
    if (OperationChoice == 0) // ID排序  
    {  
        for (int i = 0; i < this->WorkerNumber - 1; i++)  
        {  
            for (int j = i; i < this->WorkerNumber; j++)  
            {  
                if(SortDirection == 1)  
                {  
                    if (this->MemberRecord[i]->ID < this->MemberRecord[j]->ID)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
                else  
                {  
                    if (this->MemberRecord[i]->ID > this->MemberRecord[j]->ID)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
            }  
        }  
    }  
    else // name排序  
    {  
        for (int i = 0; i < this->WorkerNumber - 1; i++)  
        {  
            for (int j = i; i < this->WorkerNumber; j++)  
            {  
                if (SortDirection == 1) // max->min  
                {  
                    if (this->MemberRecord[i]->name < this->MemberRecord[j]->name)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
                else // min->max  
                {  
                    if (this->MemberRecord[i]->name > this->MemberRecord[j]->name)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
            }  
        }  
    }  
  
    this->ShowAllInf(); // 显示排序结果  
}  
  
void Operation::ClearData()  
{  
    ifstream ifs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::trunc); // 清空文件内容  
    ifs.close();  
  
    this->FileState = 0;  
    for (int i = 0; i < this->WorkerNumber; i++)  
    {  
        delete this->MemberRecord[i];  
    }  
    this->MemberRecord = nullptr;  
    this->WorkerNumber = 0;  
}  
  
Operation::~Operation()  
{  
  
}  

Operation类的功能

我们必须要有一个类体对于该系统所有的动作进行顶层规划，这个类就是我们这里的operation类。

Operation类的数据成员

int WorkerNumber; // 职工数量  
Worker** MemberRecord; // 职工信息存储数组  
bool FileState; // 文件的状态(空文件/根本没有创建这个文件/包含数据的正常文件)  

一定要注意：当我们增加成员，删除成员，修改成员信息时，一定要更新相应的参数，被改变的参数与操作的关系如下：

参数名称	参数名称	参数名称	操作
WorkerNumber	MemberRecord		特定职工元素的删除
WorkerNumber	MemberRecord	FileState	初始化operation类成员
WorkerNumber	MemberRecord	FileState	添加职工信息
WorkerNumber	MemberRecord	FileState	请空文档信息
	MemberRecord		对所有职工进行排序

operation类的初始化过程

operation类的构造函数

Operation::Operation()  
{  
    this->MemberRecord = nullptr; // 初始化数据数组位空  
    this->WorkerNumber = 0; // 初始化初始人数为0  
  
    ifstream ifs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::in);  
    if (!ifs.is_open())  
    {  
        cout << "文件打开失败！" << endl;  
        this->FileState = 0; // 文件未打开  
        ifs.close(); // 文件打开失败因此关闭文件流  
        return;  
    }  
  
    char ch;  
    ifs >> ch; // 先读取一个字符后判断文件指针是否在末尾就知道文件是否为空文件  
    if (ifs.eof())  
    {  
        FileState = false; // 文件为空文件  
    }  
    else  
    {  
        FileState = true; // 文件非空且存在  
    }  
    ifs.close(); // 判断文件数据是否非空后，关闭文件流  
  
    this->InitWorkerInf(); // 将文件的信息读取到内存当中  
}  

一定要注意：

① 判断文件是否为空的技巧：

先读一个字符，然后判断文件指针是否位于文件结尾。

② 什么时候FileState变量为false？

⑴ 文件没有被创建；

⑵ 文件中没有包含任何信息，即空文件；

③ FileState变量有什么用？

⑴ 当我们要求显示文件中的数据时，文件打不开或者空文件都会导致文件中信息显示不出来；

⑵ 当我们进行文件交互时，我们要培养一个好习惯，每当进行某项操作时，我们要将操作的状态记录下来；

文件信息的读入函数

void Operation::InitWorkerInf()  
{  
    ifstream ifs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::in);  
  
    int num = 0;  
    int ID;  
    string name;  
    int Position;  
  
    //1:Boss;2:Manager;3:Employee  
    ifs.seekg(0, ios::beg);  
    while (ifs >> ID && ifs >> name && ifs >> Position)  
    {  
        num++; // 记录原文件中的成员个数  
    }  
    ifs.close();  
  
    this->WorkerNumber = num;  
    MemberRecord = new Worker*[this->WorkerNumber];  
  
    int index = 0;  
    ifs.open("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::in);  
    ifs.seekg(0, ios::beg);  
    while (ifs >> ID && ifs >> name && ifs >> Position)  
    {  
        Worker* Object = nullptr;  
  
        switch (Position)  
        {  
        case 1:  
            Object = new Boss(ID, name, Position);  
            break;  
        case 2:  
            Object = new Manager(ID, name, Position);  
            break;  
        case 3:  
            Object = new Employee(ID, name, Position);  
            break;  
        default:  
            break;  
        }  
  
        MemberRecord[index] = Object;  
        index++;  
    }  
}  

初始时文件信息读入的流程：

① 打开文件；

② 循环读入文本信息来判断文件中职工的数量；

③ 循环读入文本的信息(文件中变量存储时有空格间隔因此可以像程序中写的那样用输入流>>循环读入)；

④ 根据职位来申请不同类型的内存。

Operation类的具体功能

显示菜单操作

void Operation::ShowMenu()  
{  
    cout << "********************************************" << endl;  
    cout << "********* 欢迎使用职工管理系统！ **********" << endl;  
    cout << "************* 0.退出管理程序 *************" << endl;  
    cout << "************* 1.增加职工信息 *************" << endl;  
    cout << "************* 2.显示职工信息 *************" << endl;  
    cout << "************* 3.删除离职职工 *************" << endl;  
    cout << "************* 4.修改职工信息 *************" << endl;  
    cout << "************* 5.查找职工信息 *************" << endl;  
    cout << "************* 6.按照编号排序 *************" << endl;  
    cout << "************* 7.清空所有文档 *************" << endl;  
    cout << "********************************************" << endl;  
    cout << endl;  
}  

退出操作

void Operation::ExitOperation()  
{  
    int IsExitOperation = 0;  
    cout << "是否退出程序？(1：是；0：否)：";  
    cin >> IsExitOperation;  
    if (IsExitOperation == 1)  
    {  
        cout << "退出程序成功." << endl;  
        exit(0);  
    }  
}  

添加新成员

void Operation::AddMember()  // 将新成员添加到类成员动态数组中
{  
    Worker** NewMember = nullptr;  
    Worker* Object = nullptr;  
    int IncreasedNumber = 0;  
  
    cout << "请输入新添加工作人员的总人数：";  
    cin >> IncreasedNumber;  
  
    NewMember = new Worker*[this->WorkerNumber + IncreasedNumber]; // 申请足够的存储空间  
  
    if(this->WorkerNumber != 0) // 将已存在的人员移入新数组中  
    {  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            NewMember[i] = MemberRecord[i];  
        }  
    }  
    for (int i = this->WorkerNumber; i < this->WorkerNumber + IncreasedNumber; i++)  
    {  
        int PositionChoice = 0;  
        cout << "请输入工作人员的职位(1:Boss;2:Manager;3:Employee)：";  
        cin >> PositionChoice;  
  
        string name;  
        cout << "请输入职工姓名：";  
        cin >> name;  
  
        int ID = 0;  
        cout << "请输入职工的ID：";  
        cin >> ID;  
  
        for (int j = 0; j < i - 1; j++)  
        {  
            if (NewMember[j]->ID == ID)  
            {  
                cout << "输入ID重复" << endl;  
                return;  
            }  
        }  
          
        switch (PositionChoice) // 根据职位进行相应的初始化  
        {  
        case 1:  
            Object = new Boss(ID, name, PositionChoice);  
            break;  
        case 2:  
            Object = new Manager(ID, name, PositionChoice);  
            break;  
        case 3:  
            Object = new Employee(ID, name, PositionChoice);  
            break;  
        default:  
            break;  
        }  
  
        NewMember[i] = Object; // 将单个职工的数据信息并入总数据信息中  
    }  
    this->MemberRecord = NewMember; // 当前员工数据数组更新  
    this->WorkerNumber += IncreasedNumber; // 当前员工数量更新  
    this->SaveInf(); // 保存信息  
}  
  
void Operation::SaveInf()  // 将数据保存到文件中
{  
    ofstream ofs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::out);  
    if (!ofs.is_open())  
    {  
        cout << "文件打开失败！" << endl;  
        return;  
    }  
    for (int i = 0; i < this->WorkerNumber; i++)  
    {  
        ofs << MemberRecord[i]->ID << " " << MemberRecord[i]->name << " " << MemberRecord[i]->Position << endl;  
    }  
    ofs.close(); // 关闭文件流  
}  

注意：我们这里添加新成员经历了两步：

① 将新成员添加至内存当中的动态数组中；

② 将动态数组中的数据存到文件中；

我们这里添加新成员时，会把以前存储信息的数组弃用，并且将旧数组数据和新添加的数据移入新的内存空间中，我们一定要在移完数据后将旧数组的内存释放掉。

显示当前所有数据的函数

void Operation::ShowAllInf()  
{  
    if (this->FileState != false)  
    {  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            this->MemberRecord[i]->ShowInf(); // 使用多态显示每一个职工的信息  
        }  
    }  
    else  
    {  
        cout << "显示失败，原因：空文件或者文件打开失败！" << endl;  
    }  
}  

删除特定职工数据的函数

int Operation::IsExist()  
{  
    int ID = 0;  
    cout << "请输入职工的ID：";  
    cin >> ID;  
  
    for (int i = 0; i < this->WorkerNumber; i++)  
    {  
        if (MemberRecord[i]->ID == ID)  
        {  
            return i;  
        }  
    }  
    return -1;  
}  
  
void Operation::DeleteMember()  
{  
    int Order = this->IsExist(); // 获取目标员工的在数组中的序号  
    if (Order == -1)  
    {  
        cout << "删除失败，查无此人" << endl;  
        return;  
    }  
  
    int ID = this->MemberRecord[Order]->ID;  
  
    delete MemberRecord[Order];  
  
    for (int i = Order; i < this->WorkerNumber - 1; i++)  
    {  
        this->MemberRecord[i] = this->MemberRecord[i + 1];  
    }  
  
    Worker** temp = new Worker*[this->WorkerNumber - 1];  // 删除了一个人，剩下“this->WorkerNumber – 1”个人
    for (int i = 0; i < this->WorkerNumber - 1; i++)  
    {  
        temp[i] = this->MemberRecord[i];  
    }  
  
    for (int i = 0; i < this->WorkerNumber; i++) // 清空就内存区域  
    {  
        delete this->MemberRecord[i];  
    }  
  
    this->MemberRecord = temp; // 更新员工数据数组  
    this->WorkerNumber--; // 删除员工需更新员工人数  
    cout << "ID为" << ID << "的员工被删除成功" << endl;  
}  

我们实现删除功能时，一般先查找这个职工在数组中的位置，并且通过这个位置来修改信息，步骤如下：

① 将数组中删除位置以后的元素向前移，此时在逻辑上删除了这个元素，但是并没有释放对应的内存空间；

② 在堆区创建一个新的动态数组，并将旧数组中的元素移入新的动态数组中；

③ 释放旧动态数组的堆区内存空间，然后将新动态数组的首地址保存至类的成员变量中。

修改职工信息的函数

void Operation::ModifyInf()  
{  
    int Order = this->FindMember();  // 和“查找特定职工的函数”搭配使用
    if (Order == -1)  
    {  
        return; // 查无此人  
    }  
  
    delete MemberRecord[Order]; // 释放旧数据的存储空间  
  
    string name;  
    int ID;  
    int Position;  
    Worker* Object;  
  
    Local:cout << "请输入员工的姓名：";  
    cin >> name;  
  
    cout << "请输入员工的ID";  
    cin >> ID;  
  
    cout << "请输入员工的职位(1:Boss;2:Manager;3:Employee):";  
    cin >> Position;  
  
    switch (Position)  
    {  
    case 1:  
        Object = new Boss(ID, name, Position);  
        break;  
    case 2:  
        Object = new Manager(ID, name, Position);  
        break;  
    case 3:  
        Object = new Employee(ID, name, Position);  
        break;  
    default:  
        cout << "输入无效" << endl;  
        goto Local;  
        break;  
    }  
  
    this->MemberRecord[Order] = Object; // 存储新数据  
    cout << "信息修改成功" << endl;  
}  

程序实现原理：

我想要修改第三个员工的信息，逻辑实现如下：

查找特定职工的函数

int Operation::FindMember()  
{  
    bool OperationChoice = 0;  
    cout << "请输入查找的条件(ID:0;name:1)：";  
    cin >> OperationChoice;  
  
    if (OperationChoice == 0)  
    {  
        int ID = 0;  
        cout << "请输入目标职工的ID：";  
        cin >> ID;  
  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            if (this->MemberRecord[i]->ID == ID)  
            {  
                this->MemberRecord[i]->ShowInf();  
                return i;  
            }  
        }  
    }  
    else if(OperationChoice == 1)  
    {  
        string name;  
        cout << "请输入目标职工的姓名：";  
        cin >> name;  
  
        for (int i = 0; i < this->WorkerNumber; i++)  
        {  
            if (this->MemberRecord[i]->name == name)  
            {  
                this->MemberRecord[i]->ShowInf();  
                return i;  
            }  
        }  
    }  
    else  
    {  
        cout << "查无此人" << endl;  
        return -1;  
    }  
    return -1;  
}  

这里，我不仅查找到特定的员工并且显示信息，而且我还返回这个职工在数组中的位置，为了和上面的修改职工信息的函数搭配使用，这样提高了代码的重用性，我不用再费时费力的重新编写一遍查找特定职工位置的函数了。

对于职工按照自定义的方式进行自定义排序

void Operation::SortMember()  
{  
    Worker* temp;  
  
    bool OperationChoice = 0;  
    cout << "请输入排序的依据(0:ID;1:name):";  
    cin >> OperationChoice;  
  
    bool SortDirection = 0;  
    cout << "请输入排序方向(min->max:0;max->min:1)：";  
    cin >> SortDirection;  
  
    if (OperationChoice == 0) // ID排序  
    {  
        for (int i = 0; i < this->WorkerNumber - 1; i++)  
        {  
            for (int j = i; i < this->WorkerNumber; j++)  
            {  
                if(SortDirection == 1)  
                {  
                    if (this->MemberRecord[i]->ID < this->MemberRecord[j]->ID)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
                else  
                {  
                    if (this->MemberRecord[i]->ID > this->MemberRecord[j]->ID)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
            }  
        }  
    }  
    else // name排序  
    {  
        for (int i = 0; i < this->WorkerNumber - 1; i++)  
        {  
            for (int j = i; i < this->WorkerNumber; j++)  
            {  
                if (SortDirection == 1) // max->min  
                {  
                    if (this->MemberRecord[i]->name < this->MemberRecord[j]->name)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
                else // min->max  
                {  
                    if (this->MemberRecord[i]->name > this->MemberRecord[j]->name)  
                    {  
                        temp = this->MemberRecord[i];  
                        this->MemberRecord[i] = this->MemberRecord[j];  
                        this->MemberRecord[j] = temp;  
                    }  
                }  
            }  
        }  
    }  
  
    this->ShowAllInf(); // 显示排序结果  
}  

请空文档内容

void Operation::ClearData()  
{  
    ifstream ifs("C:\\Users\\hgq15\\Desktop\\Data.txt", ios::trunc); // 清空文件内容  
    ifs.close();  
  
    this->FileState = 0;  
    for (int i = 0; i < this->WorkerNumber; i++)  
    {  
        delete this->MemberRecord[i];  
    }  
    this->MemberRecord = nullptr;  
    this->WorkerNumber = 0;  
}  

没必要先对内存中的职工信息进行清空，然后再将内存中空的职工信息写入文件，这样是错误的，直接将文件重建就OK了，一定要注意这里的成员变量的赋值操作。

职工类的实现

工作人员基类的实现

Worker.h

#pragma once  
  
#include <iostream>  
#include <string>  
using namespace std;  
  
//1:Boss;2:Manager;3:Employee  
class Worker  
{  
public:  
    int ID;  
    string name;  
    int Position;  
    string WorkContent;  
public:  
    Worker();  
    virtual void ShowInf() = 0;  
    virtual ~Worker();  
};  

 Worker.cpp

#include "Worker.h"  
	  
Worker::Worker()  
{  
	    this->ID = 0;  
        this->name = "无";  
	    this->Position = 0;  
	    this->WorkContent = "未定";  
}  
  
Worker::~Worker()  
{  
	  
}  

注意：我们用基类以及三个共有派生类实现了用子类指针调用父类成员函数的多态操作，类的关系如下：

 

我们可以根据worker类型的指针指向的不同父类实例对象，调用拥有不同实现方式的同名函数。

经理类的实现

Manager.h

#pragma once  
  
#include "Worker.h"  
#include <iostream>  
#include <string>  
using namespace std;  
  
class Manager :public Worker  
{  
public:  
    Manager(int ID, string name, int Position);  
    void ShowInf();  
    ~Manager();  
}; 

 

Manager.cpp

#include "Manager.h"  
  
Manager::Manager(int ID, string name, int Position)  
{  
    this->ID = ID;  
    this->name = name;  
    this->Position = Position;  
    this->WorkContent = "听从老板的安排，给员工安排任务";  
}  
  
void Manager::ShowInf()  
{  
    cout << "ID:" << this->ID << '\t' << "name:" << this->name << '\t' << "Position:" << this->Position << '\t'  
        << "WorkContent:" << this->WorkContent << endl;  
}  
  
Manager::~Manager()  
{  
  
} 

 

老板类的实现

Boss.h

#pragma once  
  
#include "Worker.h"  
#include <iostream>  
#include <string>  
using namespace std;  
  
class Boss :public Worker  
{  
public:  
    Boss(int ID, string name, int Position);  
    void ShowInf();  
    ~Boss();  
};  

Boss.cpp

#include "Boss.h"  
  
Boss::Boss(int ID, string name, int Position)  
{  
    this->ID = ID;  
    this->name = name;  
    this->Position = Position;  
    this->WorkContent = "顶层规划，将工作派发给经理";  
}  
  
void Boss::ShowInf()  
{  
    cout << "ID:" << this->ID << '\t' << "name:" << this->name << '\t' << "Position:" << this->Position << '\t'  
        << "WorkContent:" << this->WorkContent << endl;  
}  
  
Boss::~Boss()  
{  
  
}