C++基于多态的职工管理系统完整代码

1.头文件.h 部分：

1.1  Worker.h

/*

	这是一个抽象的职工父类，以下类都继承自该类：
	1.Employee类 
	2.Manager类 
	3.Boss类 

*/

#pragma once  
#include  
#include
using namespace std; //使用标准命名空间 

class Worker
{
	public:
		//1.显示个人信息 
		virtual void Show_Info() = 0;
		
		//2.获取岗位名称
		virtual string Get_DeptName() = 0; 
		
		//职工编号 
		int W_Id;
		//职工姓名 
		string W_Name;
		//职工所在部门名称编号 
		int W_DeptId; 
};

1.2  Employee.h

#pragma once  //防止头文件重复包含 

/*这是一个普通员工类，该类继承自Worker类，并实现了父类Worker中的纯虚函数。*/ 

#include  //包含标准输入输出流 
#include
#include "Worker.h"
using namespace std; //使用标准命名空间

class Employee:public Worker
{
	public:
		//1.构造函数
	    Employee(int id, string name, int dept_id);
		
		//2.显示个人信息 
	    void Show_Info();
		
		//3.获取岗位名称
		string Get_DeptName(); 
};

1.3  Manager.h

#pragma once  //防止头文件重复包含
/*这是一个经理类，该类继承自Worker类，并实现了父类Worker中的纯虚函数。*/ 

#include  //包含标准输入输出流 
#include
#include "Worker.h"
using namespace std; //使用标准命名空间 

class Manager:public Worker
{
	public:
		//1.构造函数
	    Manager(int id, string name, int dept_id);
		
		//2.显示个人信息 
	    void Show_Info();
		
		//3.获取岗位名称
		string Get_DeptName(); 
};

1.4  Boss.h

#pragma once  //防止头文件重复包含 

/*这是一个老板类，该类继承自Worker类，并实现了父类Worker中的纯虚函数。*/ 

#include  //包含标准输入输出流 
#include
#include "Worker.h"
using namespace std; //使用标准命名空间 

class Boss:public Worker
{
	public:
		//1.构造函数
	    Boss(int id, string name, int dept_id);
		
		//2.显示个人信息 
	    void Show_Info();
		
		//3.获取岗位名称
		string Get_DeptName(); 

};

1.5  DataStructType.h

//这是一个职工数据链表的结点结构和头指针结构的声明头文件 

#pragma once  //防止头文件重复包含 

//职工数据链表结点结构 
typedef struct wlist 
{
	Worker* WorkerDataPtr;//职工链表结点数据域
	wlist* next;
}WorkerLinkNode;

//职工数据链表头指针结构 
typedef struct header
{
	int worker_num;  //记录当前链表的结点数（职工人数） 
	WorkerLinkNode* next;
}Header;

1.6  WorkerMangers.h

#pragma once  //防止头文件重复包含 
/*
该头文件声明了一个WorkerManager类，用于实现职工信息的管理。该类包含了一些成员函数，
如构造函数、添加职工、显示职工、修改职工、删除职工等。同时，它还包含一些用于管理
职工链表的成员变量，如链表的头指针和尾指针，以及一些与文件相关的标志。
*/
#include  //包含标准输入输出流 
#include
#include "Worker.h"
#include "DataStructType.h"
#define EMPFILE "DataFile.txt"

using namespace std; //使用标准命名空间 

//创建职工管理类 
class WorkerManger
{
	public:          
	                                   
		/*****************************WorkerManger类成员函数相关声明*****************************/
		//1.WorkerManger类的构造函数 
		WorkerManger();
		
		//2..读取当前打开文件中的职工人数
		int Get_WorkerNum();
		
		//3.初始化职工数据链表 
		void Init_WorkerLinkList();
		
		//4.显示系统菜单函数
		void Show_Menu();
		
		//5.退出系统函数
		void Exit_System(); 
		 
		//6.添加职工功能函数
		void Add_worker(); 

		//7.保存员工信息到文件
		void Save_File();
		
		//8.显示职工数据
		void Show_worker(); 
		
		//9.查找职工
		void FinD_Worker();
		
		//10.修改职工信息
		void MoD_Worker(); 
		
		//11.删除职工信息
		void Del_Worker(); 
		
		//12.检查当前链表是否为空
		bool Is_Empty_LinkList(); 
		
		//13.排序职工链表及文件数据
		void Sort_Worker();
		
		//14.升序排序函数 
		void Asce_sort(int low, int high, WorkerLinkNode* Array); 
		
		//15.降序排序函数
		void DesE_sort(int low, int high, WorkerLinkNode* Array);
		 
		//16.清空文件数据
		void Clean_File();
		
		//17.根据职工编号判断职工是否存在，存在则返回结点指针 ，否则返回空 
		WorkerLinkNode* Is_ExistWorker(int E_id);	
		
		//18.根据职工姓名判断职工是否存在，存在则返回结点指针 ，否则返回空 
		WorkerLinkNode* Is_ExistWorker(string E_name);
		
		//19.返回当前数据结点的前驱结点，无前驱结点则返回空 
		WorkerLinkNode* Get_Pre(WorkerLinkNode* &curr_node);
		
		//20.返回当前数据结点的后继结点，无后继结点则返回空  
		WorkerLinkNode* Get_Suc(WorkerLinkNode* &curr_node); 
		
		//21.将链表数据存在到临时数组中，便于排序
		WorkerLinkNode* Store_Array();
		
		//22.将排好序的数组数据，连接成链表
		WorkerLinkNode* Recom_Link(WorkerLinkNode* Array);
		
		 
		
		//23.WorkerManger类的析构函数 
		~WorkerManger();	
			
		/*****************************WorkerManger类成员变量相关声明*****************************/
		
		//1.职工链表头指针
		Header*LinkHeader; 
		
		//2.职工链表尾指针
		WorkerLinkNode* EndPtr; 
		
		//3.判断文件是否为空标志
		bool File_IsEmpty;
		
		//4.判断文件是否存在标志
		bool File_IsExist; 
};

2.实现文件.cpp 部分：

2.1  Employee.cpp

//Employee 的类的实现
#include "Employee.h"

//构造函数
Employee::Employee(int id, string name, int dept_id)
{
	this->W_Id = id;
	this->W_Name = name;
	this->W_DeptId = dept_id;
}
		
//显示个人信息 
void Employee::Show_Info()
{
	cout << "岗位编号：" << this->W_Id
	     << "\t职工姓名：" << this->W_Name
	     << "\t岗位：" << this->Get_DeptName()
	     << "\t岗位职责： 完成经理交给的任务" << endl; 
}
		
//获取岗位名称
string Employee::Get_DeptName()
{
	return "员工"; 
} 

2.2   Manager.cpp

//Manager 的类的实现
#include "Manager.h"

//构造函数
Manager::Manager(int id, string name, int dept_id)
{
	this->W_Id = id;
	this->W_Name = name;
	this->W_DeptId = dept_id;
}
		
//显示个人信息 
void Manager::Show_Info()
{
	cout << "岗位编号：" << this->W_Id
	     << "\t职工姓名：" << this->W_Name
	     << "\t岗位：" << this->Get_DeptName()
	     << "\t岗位职责： 完成老板交给的任务，并下发任务给员工" << endl; 
}
		
//获取岗位名称
string Manager::Get_DeptName()
{
	return "经理"; 
} 

2.3   Boss.cpp

//Boss 的类的实现
#include "Boss.h"

//构造函数
Boss::Boss(int id, string name, int dept_id)
{
	this->W_Id = id;
	this->W_Name = name;
	this->W_DeptId = dept_id;
}
		
//显示个人信息 
void Boss::Show_Info()
{
	cout << "岗位编号：" << this->W_Id
	     << "\t职工姓名：" << this->W_Name
	     << "\t岗位：" << this->Get_DeptName()
	     << "\t岗位职责： 管理公司所有事务" << endl; 
}
		
//获取岗位名称
string Boss::Get_DeptName()
{
	return "总裁"; 
}

2.4   WorkerMangers.cpp

//WorkerManager类的实现 
/********************************************头文件包含域*************************************/

#include "WorkerMangers.h"
#include "Worker.h"
#include "Employee.h"
#include "Manager.h"
#include "Boss.h"
#include 
using namespace std;


/*************************************WorkerManger类的成员函数实现域******************************/

//1.构造函数 
WorkerManger::WorkerManger()
{
	//1.构建职工链表头指针结点和尾指针，指针初始为空,结点数初始化为0  
	this->LinkHeader = new Header;
	this->LinkHeader->next =NULL;
	this->LinkHeader->worker_num = 0;
	EndPtr = NULL;
	
	//2.判断职工数据文件是否存在 
	ifstream ifs;
	ifs.open(EMPFILE, ios::in);
	
	//1.文件不存在
	if(!ifs.is_open())
	{
		cout << "文件不存在！" << endl;
		
		//初始化标记 
		this->File_IsEmpty = true; //文件为空 
		this->File_IsExist = false; //文件不存在 
		return;
	}
	//2.文件存在
	else
	{
		//2.1检查当前文件是否为空文件 
		char ch;
		ifs >> ch;
		
		if(ifs.eof())  //2.1.1文件为空的情况 
		{
			cout << "文件为空！" << endl;
			//初始化标记 
			this->File_IsEmpty = true; //文件为空 
			this->File_IsExist = true; //文件存在 
			ifs.close();
			return; 
		}
		else //2.1.2文件不为空的情况 
		{
			//读取文件数据到链表中 
			int num = this->Get_WorkerNum();
			cout << "当前职工人数：" << num << endl;
			this->File_IsEmpty = false;//文件不为空 
			this->File_IsExist = true; //文件存在
			ifs.close();
		}
	} 
}

/********************************************************************************************/
//2.读取当前打开文件中的职工人数
int WorkerManger::Get_WorkerNum()
{
	//1.打开文件 
	ifstream ifs;
	ifs.open(EMPFILE, ios::in);//以读文件方式打开文件 
	
	//2.创建临时变量，用于读取文件 
	int G_id;  //职工编号 
	string G_name; //职工姓名
	int G_deptId; //职工所在部门名称编号
	
	 //3.读取文件数据 
	int num; //记录文件中职工人数
	while(ifs >> G_id && ifs >> G_name && ifs >> G_deptId) 
	{
		num++;
	}
	
	//关闭文件 
	ifs.close();
	
	return num;
}

/********************************************************************************************/
//3.初始化职工数据链表 
void WorkerManger::Init_WorkerLinkList()
{
	//1.检查当前文件是否存在 
	if(this->File_IsExist)  //存在 
	{
		if(this->File_IsEmpty == false)  //文件不为空 
		{
			//1.1创建流对象，以读文件方式打开文件 
			ifstream ifs;
			ifs.open(EMPFILE, ios::in);
		
			//2.创建临时变量，临时存储文件中读取的职工数据 
			int I_id;
			string I_name;
			int I_deptId;
		
			//2.1用于标记第一次链接(头指针指向第一个数据结点） 
			int first = 1; 
	
			//3.开始读取职工文件数据 
			while(ifs >> I_id && ifs >> I_name && ifs >> I_deptId) 
			{
				//3.1创建文件数据结点 
				WorkerLinkNode* file_worker = new WorkerLinkNode;
				
				//3.2根据职工部门编号 deptId 选择创建相对应的结点数据域 
				switch(I_deptId)
				{
					case 1:
						file_worker->WorkerDataPtr = new Employee(I_id, I_name,1);
						break;
					case 2:
						file_worker->WorkerDataPtr = new Manager(I_id, I_name,2);
						break;
					case 3:
						file_worker->WorkerDataPtr = new Boss(I_id, I_name,3);
						break;
				}
				//4.将数据节点依次链接到链表中
				if(first)//4.1头指针链接第一个文件数据结点 
				{
					this->LinkHeader->next = file_worker;
					this->EndPtr = file_worker;
					first = 0;
				} 
				else  //依次链接后续数据结点 
				{
					this->EndPtr->next = file_worker;
					this->EndPtr = this->EndPtr->next;
				}
				this->LinkHeader->worker_num++;
			}
			this->EndPtr->next = NULL;  //5.将尾结点的指针指向空
			
			//6.关闭文件
			ifs.close();
		}
		else  //文件为空 
		{
			return; 
		} 	
	}
	else  //不存在 
	{
		cout << "文件不存在，请检查文件路径是否正确！" << endl;
		return;
	}
	   
}

/********************************************************************************************/
//4.显示系统菜单函数
void WorkerManger::Show_Menu()
{
	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; 
}

/********************************************************************************************/
//5.退出系统函数 
void WorkerManger::Exit_System()
{
	cout << "欢迎下次使用！" << endl;
	system("pause");
	system("cls");
	exit(0);
}

/********************************************************************************************/
//6.添加职工信息函数
void WorkerManger::Add_worker()
{
	//1.检查文件是否存在 
	if(!this->File_IsExist)
	{
		cout << "文件不存在，无法添加！请检查文件路径是否合法" << endl;
		return;
	}
	
	//2.输入添加新员工数量
	int add_num = 0;  
	cout << "请输入增加职工数量：" << endl;
	cin >> add_num;
	
	//3.检查输入是否合法 
	if(add_num < 0)
	{
		cout << "输入有误！" << endl;
		system("pause");
		system("cls");
		return;
	}
	
	//4.开始添加员工数据 
	for(int i = 0;i < add_num;i++)
	{
		//4.1.创建临时变量，临时存储用户输入的职工数据
		int A_Id;
		string A_Name; 
		int A_Dselect; 
		
		
		//4.2依次输入数据 
		cout << "请输入第" << i+1 << "个新职工编号：" << endl; 
		cin >> A_Id;
		cout << "请输入第" << i+1 << "个新职工姓名：" << endl; 
		cin >> A_Name;
		
		cout << "请选择该职工的岗位：" << endl;
		cout << "1. 普通职工" << endl; 
		cout << "2. 经理" << endl; 
		cout << "3. 老板" << endl;  
		cin >> A_Dselect;
		
		//4.3对所输入的职工部门编号进行检查	
		while(A_Dselect != 1 && A_Dselect != 2 && A_Dselect != 3) 
		{
			cout << "输入有误,请重新输入：" << endl;
			cin >> A_Dselect;
		}
		
		//4.4创建职工数据结点 
		WorkerLinkNode* new_worker = new WorkerLinkNode;
		
		//4.5根据所输入的职工部门编号，创建相应的链表结点数据域 
		switch(A_Dselect)
		{
			case 1:
				new_worker->WorkerDataPtr = new Employee(A_Id, A_Name,1);
				break;
			case 2:
				new_worker->WorkerDataPtr = new Manager(A_Id, A_Name,2);
				break;
			case 3:
				new_worker->WorkerDataPtr = new Boss(A_Id, A_Name,3);
				break;
		}
		
		//4.6动态更新尾指针 
		bool is_emptyLink = this->Is_Empty_LinkList();
		if(is_emptyLink == false) //当前链表不为空的处情况 ，初始化时头指针已经指向第一个数据结点，这里只需要处理尾指针 
		{
			this->EndPtr->next = new_worker;
			this->EndPtr = new_worker;
			this->LinkHeader->worker_num++;
		}
		else  //当前链表为空的情况，初始化时头尾指针均为空 
		{
			this->LinkHeader->next = new_worker;
			this->EndPtr = new_worker;
			this->LinkHeader->worker_num++;
		} 
	}
	
	//5.链表尾结点指向空 
	this->EndPtr->next = NULL; 
	
	system("pause");
	system("cls");
}

/********************************************************************************************/
//7.将链表数据重写入文件中 
void WorkerManger::Save_File()
{
	//1.检查文件是否存在 
	if(!this->File_IsExist)
	{
		cout << "文件不存在，无法保存！请检查文件路径是否合法" << endl;
		return;
	}
	
	//2.创建流对象,以写文件的方式打开文件 
	ofstream ofs;
	ofs.open(EMPFILE, ios::out);

	//3.保存数据 
	WorkerLinkNode* wptr = this->LinkHeader->next;//用于提取每个职工的结点数据 
	//依次读取文件 
	while(wptr != NULL)
	{
		ofs << wptr->WorkerDataPtr->W_Id << " " 
		    << wptr->WorkerDataPtr->W_Name << " " 
			<< wptr->WorkerDataPtr->W_DeptId << endl;
		wptr = wptr->next;
		//更新文件标记，表示当前文件不为空 
		this->File_IsEmpty = false;
	}
	
	//关闭文件 
	ofs.close(); 	
}
/********************************************************************************************/
//8.显示当前文件中所有员工数据 
void WorkerManger::Show_worker()
{
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空！" << endl;
	}
	else
	{
		WorkerLinkNode* get = this->LinkHeader->next;//用于提取每个职工的结点数据
		while(get != NULL)
		{
			get->WorkerDataPtr->Show_Info();
			get = get->next;
		}

	}
	system("pause");
	system("cls");
} 

/********************************************************************************************/
//9.查找职工
void WorkerManger::FinD_Worker()
{
	//1.检查文件是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空,无法查找！" << endl;
		return;
	}
	
	//2.根据用户输入选择对应查找方式 
	int check_choice = 1;
	cout << "请输入查找方式：" << endl;
	cout << "1.按职工编号查找" << endl;
	cout << "2.按姓名查找" << endl;
	cin >> check_choice;
	
	//3.开始查找 
	int E_id;
	string E_name;
	WorkerLinkNode* result = NULL;
	switch(check_choice)
	{
		case 1:
			
			cout << "请输入职工编号：" << endl;
			cin >> E_id;
			result = this->Is_ExistWorker(E_id);//编号查找
			if(result)
			{
				cout << "查找成功，该职工信息如下：" << endl;
				result->WorkerDataPtr->Show_Info();
			}
			else
			{
				cout << "查无此人！" << endl;
			}
			break;
			
		case 2:
			
			cout << "请输入职工姓名：" << endl;
			cin >> E_name;
			result = this->Is_ExistWorker(E_name);//姓名查找
			if(result)
			{
				cout << "查找成功，该职工信息如下：" << endl;
				result->WorkerDataPtr->Show_Info();
			}
			else
			{
				cout << "查无此人！" << endl;
			}
			break;  
			
		default:
			cout << "输入错误，查无此人！" << endl;
			break;   
	}
	system("pause");
	system("cls");
} 

/********************************************************************************************/
//10.修改职工信息
void WorkerManger::MoD_Worker()
{
	//1.检查文件是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空,无法查找！" << endl;
		system("pause");
		system("cls");
		return;
	}
	
	//2.用户输入需要需改信息的职工编号
	int M_id;
	cout << "请输入职工编号：" << endl;
	cin >> M_id;
	
	//3.查找该职工是否存在
	WorkerLinkNode* wk = this->Is_ExistWorker(M_id);
	
	if(wk) //该职工存在 
	{
		//4.1输出提示信息 
		cout << "查到" << M_id << "号职工" << endl; 
		
		//4.2开始修改职工信息 
		string M_name; //创建临时变量存储信息
		int M_deptId;
		
		cout << "输入新姓名：" << endl;
		cin >> M_name;
		cout << "输入岗位：" << endl;
		cout << "1. 普通职工" << endl; 
		cout << "2. 经理" << endl; 
		cout << "3. 老板" << endl; 
		cin >> M_deptId; 
		
		//4.3根据所输入的职工部门编号，创建相应的链表结点数据域 
		switch(M_deptId)
		{
			case 1:
				wk->WorkerDataPtr = new Employee(M_id, M_name,1);
				break;
			case 2:
				wk->WorkerDataPtr = new Manager(M_id, M_name,2);
				break;
			case 3:
				wk->WorkerDataPtr = new Boss(M_id, M_name,3);
				break;
		}
		 
	}
	else  //不存在 
	{
		cout << "查无此人！" << endl;
		system("pause");
		system("cls");
		return; 
	}
	system("pause");
	system("cls");
	
	 
}

/********************************************************************************************/
//11.删除职工信息
void WorkerManger::Del_Worker()
{
	//1.检查文件是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空,无法查找！" << endl;
		return;
	}
	
	//2.根据用户输入选择对应查找方式 
	int check_choice = 1;
	cout << "请输入查找方式：" << endl;
	cout << "1.按职工编号查找" << endl;
	cout << "2.按姓名查找" << endl;
	cin >> check_choice;
	
	//3.开始查找 
	int D_id;
	string D_name;
	int D_flag = 0;//标记是否删除职工信息， 
	WorkerLinkNode* result = NULL;
	switch(check_choice)
	{
		case 1:
			
			cout << "请输入需要删除的职工编号：" << endl;
			cin >> D_id;
			result = this->Is_ExistWorker(D_id);//编号查找
			if(result != NULL)
			{
				cout << "查找成功，该职工信息如下：" << endl;
				result->WorkerDataPtr->Show_Info();
				
				cout << "确定要删除该职工所有信息？" << endl;
				cout << "1.确定删除！" << endl;
				cout << "0.在考虑一下" << endl; 
				cin >> D_flag;
				
				if(D_flag==1)//确定删除数据 
				{
					//获取被删除结点的前驱节点和后继结点 
					WorkerLinkNode* pre = NULL;  //前驱节点
					WorkerLinkNode* suc =NULL;   //后继结点
					
					if(this->LinkHeader->next == result)  //1.需要删除的结点为第一个结点 
					{
						this->LinkHeader->next = this->LinkHeader->next->next;
						
					}
					else  //2.要删除的结点不是第一个结点 
					{
						//2.创建临时指针，用于遍历查找目标职工结点 
						WorkerLinkNode* temptr = this->LinkHeader->next;
	
						//3.开始遍历查找
						while(temptr->next != result)
						{
							temptr = temptr->next;
						}
						temptr->next = temptr->next->next;
						//更新尾指针
						while(temptr->next != NULL)
						{
							temptr = temptr->next;
						}
						this->EndPtr = temptr;
						this->EndPtr->next = NULL;
						
					}
					
					this->LinkHeader->worker_num--; 
					//释放空间 
					delete result->WorkerDataPtr;
					result->next = NULL;
					delete result;
					result = NULL;
					
					if(result == NULL)
					{
						cout << "成功删除该职工结点！" << endl;
					}
					else
					{
						cout << "删除失败！" << endl;
					}
					
				}
				else if(D_flag == 0)  //放弃删除数据 
				{
					system("pause");
					system("cls");
					return;
				}
				else
				{
					cout << "输入错误！" << endl;
					system("pause");
					system("cls");
					return;
				}
			}
			else
			{
				cout << "查无此人！" << endl;
			}
			break;
			
		case 2:
			
			cout << "请输入需要删除的职工姓名：" << endl;
			cin >> D_name;
			result = this->Is_ExistWorker(D_name);//姓名查找
			if(result)
			{
				cout << "查找成功，该职工信息如下：" << endl;
				result->WorkerDataPtr->Show_Info();
				
				cout << "确定要删除该职工所有信息？" << endl;
				cout << "1.确定删除！" << endl;
				cout << "0.在考虑一下" << endl; 
				cin >> D_flag;
				
				if(D_flag == 1)//确定删除数据 
				{
					//获取被删除结点的前驱节点和后继结点 
					WorkerLinkNode* pre = NULL;  //前驱节点
					WorkerLinkNode* suc =NULL;   //后继结点
					
					if(this->LinkHeader->next == result)  //1.需要删除的结点为第一个结点 
					{
						this->LinkHeader->next = this->LinkHeader->next->next;
						
					}
					else  //2.要删除的结点不是第一个结点 
					{
						//2.创建临时指针，用于遍历查找目标职工结点 
						WorkerLinkNode* temptr = this->LinkHeader->next;
	
						//3.开始遍历查找
						while(temptr->next != result)
						{
							temptr = temptr->next;
						}
						temptr->next = temptr->next->next;
					}
					//释放空间 
					delete result->WorkerDataPtr;
					delete result;
					result = NULL;
					

					if(result == NULL)
					{
						cout << "成功删除该职工结点！" << endl;
					}
					else
					{
						cout << "删除失败！" << endl;
					}	
				}
				else if(D_flag == 0)  //放弃删除数据 
				{
					system("pause");
					system("cls");
					return;
				}
				else
				{
					cout << "输入错误！" << endl;
					system("pause");
					system("cls");
					return;
				}
			}
			else
			{
				cout << "查无此人！" << endl;
			}
			break;  
			
		default:
			cout << "输入错误，查无此人！" << endl;
			break;   
	}
	system("pause");
	system("cls");
}

//12.检查当前链表是否为空 
bool WorkerManger::Is_Empty_LinkList()
{
	if(this->LinkHeader->next == NULL)
	{
		return true;
	}
	return false;
}

/********************************************************************************************/		
//13.排序职工链表及文件数据
void WorkerManger::Sort_Worker() 
{
	//1.提示用户选择排序方式 
	int s_choice = 1; 
	cout << "请选择排序方式：" << endl;
	cout << "1.按职工号进行升序" << endl;
	cout << "2.按职工号进行降序" << endl;
	cin >> s_choice;
	
	//2.将链表数据存在到临时数组中，便于排序
	WorkerLinkNode* Array = this->Store_Array();
	if(s_choice == 1) //升序 
	{
		this->Asce_sort(0, this->LinkHeader->worker_num-1, Array);
	}
	else if(s_choice == 2) //降序
	{
		this->DesE_sort(0, this->LinkHeader->worker_num-1, Array);
    }
    else
	{
		cout << "输入不合法，无法进行排序！" << endl;
	}
	
	//3.将排序好的数组重新连接成链表
	this->Recom_Link(Array); 
	cout << "排序完成！" << endl;
	Array = NULL;
	system("pause");
	system("cls");
}	

//快速排序算法函数
//14.升序 
void WorkerManger::Asce_sort(int low, int high, WorkerLinkNode* Array)
{
	int i = low;
	int j = high;
	
	if(i > j)
	{
		return;
	}
	
	WorkerLinkNode A_temp = Array[low];
	WorkerLinkNode A_t;
	while(i != j)
	{
		//升序 
		while(Array[j].WorkerDataPtr->W_Id >= A_temp.WorkerDataPtr->W_Id && i < j)
		{
			j--;
		}
	
		while(Array[j].WorkerDataPtr->W_Id <= A_temp.WorkerDataPtr->W_Id && i < j)
		{
			i++;
		}
	
		if(i < j)
		{
			A_t = Array[i];
			Array[i] = Array[j];
			Array[j] = A_t;
		}
	}
	Array[low] = Array[i];
	Array[i] = A_temp;
	
	this->Asce_sort(low, i-1, Array);
	this->Asce_sort(i+1, high, Array);
}

//15.降序 
void WorkerManger::DesE_sort(int low, int high, WorkerLinkNode* Array)
{	
	int i = low;
	int j = high;
	if(i > j)
	{
		return;
	}
	WorkerLinkNode D_temp = Array[low];
	WorkerLinkNode D_t;
	while(i != j)
	{
		//升序 
		while(Array[j].WorkerDataPtr->W_Id <= D_temp.WorkerDataPtr->W_Id && i < j)
		{
			j--;
		}
	
		while(Array[j].WorkerDataPtr->W_Id >= D_temp.WorkerDataPtr->W_Id && i < j)
		{
			i++;
		}
	
		if(i < j)
		{
			D_t = Array[i];
			Array[i] = Array[j];
			Array[j] = D_t;
		}
	}
	Array[low] = Array[i];
	Array[i] = D_temp;
	
	this->DesE_sort(low, i-1, Array);
	this->DesE_sort(i+1, high, Array);
}

//16.清空文件数据和链表数据 
void WorkerManger::Clean_File()
{
	//提示用户是否进行清空操作 
	int C_choice;
	cout << "确认清空？" << endl;
	cout << "1.确认" << endl; 
	cout << "2.返回" << endl;
	cin >> C_choice; 
	if(C_choice == 2) 
	{
		system("pause");
		system("cls");
		return;
	}
	else if(C_choice == 1)
	{
		//.清空文件存储数据
		ofstream ofs;
		ofs.open(EMPFILE, ios::trunc);
		
		//2.清空链表数据
		WorkerLinkNode* C_temp = this->LinkHeader->next;
		WorkerLinkNode* C_t = NULL;
		
		for(int i = 0;i < this->LinkHeader->worker_num;i++) 
		{
			C_t = C_temp;
			C_temp = C_temp->next;
			delete C_t->WorkerDataPtr; //清空结点数据域 
			C_t->next = NULL;  //结点指针域悬空 
		}
		
		this->LinkHeader->next = NULL;
		this->EndPtr = NULL;
		this->LinkHeader->worker_num = 0;
		cout << "成功清空所有文件数据！" << endl;
	}
	else
	{
		cout << "输入有误，无法正常操作！" << endl;
	}
	system("pause");
	system("cls");
	
}


//17.根据职工编号判断职工是否存在
WorkerLinkNode* WorkerManger::Is_ExistWorker(int E_id)
{	
	//1.检查文件是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空,无法查找！" << endl;
		return NULL;
	}
	//2.创建临时指针，用于遍历查找目标职工结点 
	WorkerLinkNode* temptr = this->LinkHeader->next;
	
	//3.开始遍历查找
	while(temptr->WorkerDataPtr->W_Id != E_id)
	{
		temptr = temptr->next;
		if(temptr == NULL)
		{
			return NULL;
		}
	}
	//4.成功找到则返回结点
	return &(*temptr);
}

//18.根据职工姓名判断职工是否存在，并返回结点指针 
WorkerLinkNode* WorkerManger::Is_ExistWorker(string E_name)
{
	//1.检查文件是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空,无法查找！" << endl;
		return NULL;
	}
	//2.创建临时指针，用于遍历查找目标职工结点 
	WorkerLinkNode* temptr = this->LinkHeader->next;
	
	//3.开始遍历查找 
	while(temptr->WorkerDataPtr->W_Name != E_name)
	{
		temptr = temptr->next;
		if(temptr == NULL)
		{
			return NULL;
		}
	}
	//4.成功找到则返回结点指针 
	return &(*temptr);
}

/********************************************************************************************/
//19.返回当前数据结点的前驱节点 
WorkerLinkNode* WorkerManger::Get_Pre(WorkerLinkNode* &curr_node)
{
	//1.检查当前职工数据链表是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "数据链表为空，无法查找！" << endl;
		return NULL;
	}
	//2.创建临时指针，用于遍历查找目标职工结点 
	WorkerLinkNode* temptr = this->LinkHeader->next;
	
	//3.检查当前查找的结点是否为链表头结点，为头结点则返回当前结点并输出提示信息 
	if(temptr == curr_node) 
	{
		cout << "该结点无前驱节点！" << endl;
		return NULL; 
	}

	//4.检查输入的参数结点指针是否为空
	if(curr_node == NULL)
	{
		cout << "该结点指针为空，无法查找继结点！" << endl;
		return NULL;
	}  
	
	//4.开始遍历查找
	while(temptr->next != curr_node)
	{
		temptr = temptr->next;
		if(temptr == NULL)
		{
			return NULL;//未找到前驱节点则返回空 
		}
	}
	//4.成功找到则返回该结点指针 
	return &(*temptr);
}

/********************************************************************************************/		
//20.返回当前数据结点的后继节点 
WorkerLinkNode* WorkerManger::Get_Suc(WorkerLinkNode* &curr_node)
{
	//1.检查当前职工数据链表是否存在以及是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "数据链表为空，无法查找！" << endl;
		return NULL;
	}
	//2.检查输入的参数结点指针是否为空
	if(curr_node == NULL)
	{
		cout << "该结点指针为空，无法查找继结点！" << endl;
		return NULL;
	} 
	
	//2.返回后继结点
	return curr_node->next;
}	

/********************************************************************************************/		
//21.将链表数据存在到临时数组中，便于排序
WorkerLinkNode*  WorkerManger::Store_Array()
{
	//1.判断链表是否为空 
	if(this->Is_Empty_LinkList())
	{
		cout << "文件不存在或记录为空！" << endl;
		return NULL; 
	}
	else
	{
		//2.创建临时数组存储节点数据 
		WorkerLinkNode* S_Array = new WorkerLinkNode[this->LinkHeader->worker_num];
		
		//3.开始提取节点数据存入数组 
		WorkerLinkNode* temp_node = this->LinkHeader->next;//用于提取每个职工的结点数据
		for(int i = 0;i < this->LinkHeader->worker_num && temp_node != NULL;i++)
		{
			S_Array[i] = *temp_node;
			temp_node = temp_node->next;
		}
		return S_Array;
	}
	
} 
/********************************************************************************************/
//22.将排好序的数组数据，连接成链表
WorkerLinkNode* WorkerManger::Recom_Link(WorkerLinkNode* Array)
{
	for(int i = 0;i < this->LinkHeader->worker_num;i++)
	{
		if(i != this->LinkHeader->worker_num-1)
		{
			Array[i].next = &Array[i+1];
		}
		else
		{
			this->EndPtr = &Array[i];
			Array[i].next = NULL;
		}
	}
	this->LinkHeader->next = &Array[0]; 
	
	Array = NULL; 
}

/********************************************************************************************/
//23.析构函数 
WorkerManger::~WorkerManger()
{
	WorkerLinkNode* W_temp = this->LinkHeader->next;
	while(W_temp != NULL) 
	{
		delete W_temp->WorkerDataPtr;
		W_temp = W_temp->next;
	}
	delete this->LinkHeader;
	this->LinkHeader = NULL;
}

2.5  职工管理系统.cpp

#include 
#include 
#include "WorkerMangers.h"
#include "Worker.h"
#include "Employee.h"
#include "Manager.h"
#include "Boss.h"
#include "DataStructType.h"
using namespace std; //使用标准命名空间 


//职工管理系统主调函数 
void WorkerManger_System()
{
	//1.启动程序，创建管理类对象 
	 WorkerManger wm;
	 
	 //2.加载职工数据文件进入链表 
	 wm.Init_WorkerLinkList(); 
	 
	 //3.进入程序主流程 
	 while(true)
	 {
	 	//3.1显示系统菜单 
	 	wm.Show_Menu();
	 	
	 	//3.2提示用户输入选择 
	 	int user_choice = 0;
	 	cout << "请输入您的选择：" << endl;
		cin >> user_choice;
		
		//3.3根据 user_choice 跳转相应成员方法进行操作 
		switch(user_choice)
		{
			case 0:
				//退出系统
				wm.Exit_System(); 
				break; 
			case 1:
				//添加职工 
				wm.Add_worker();
				wm.Save_File(); 
				break;
			case 2:
				//显示职工 
				wm.Show_worker();
				break;
			case 3:
				//删除职工 
				wm.Del_Worker(); 
				wm.Save_File();
				break;
			case 4:
				//修改职工 
				wm.MoD_Worker();
				wm.Save_File();
				break;
			case 5:
				//查找职工 
				wm.FinD_Worker();
				break;
			case 6:
				//排序职工
				wm.Sort_Worker();
				wm.Save_File();
				break;
			case 7:
				//清空文件 
				wm.Clean_File();
				break;
			default:
				system("cls");
				break; 
		}
	 }
	 system("pause");
}

int main() 
{
	//调用函数 
	WorkerManger_System();
	return 0;
}