职工管理系统

一、 需求

职工管理系统可以用来管理公司所有员工的信息

本次利用C++来实现一个基于多态的职工管理系统

公司中职工分为三类：普通职工、经理、老板。显示信息时，需要显示职工编号、职工姓名、职工岗位以及职责

普通员工职责：完成经理布置的任务

经理职责：完成老板布置的任务，并下发给员工

老板职责：管理公司所有事务

管理功能中需要实现的功能

• 退出管理程序：退出当前管理系统
• 增加职工信息：实现批量添加职工信息，将信息录入到文件中，职工信息为：职工编号、姓名、部门编号
• 显示职工信息：显示公司内部所有职工的信息
• 删除离职职工：按照编号删除指定的职工
• 修改职工信息：按照编号修改职工个人信息
• 查找职工信息：按照职工的编号或者姓名进行查找相关的人员信息
• 按照编号排序：按照职工编号，进行排序，排序规则由用户指定
• 清空所有文档：清空文件中记录的所有职工信息（清空前需要再次确认，防止误触）

二、 创建管理类

管理类赋值的内容如下

• 与用户的沟通菜单界面
• 对职工增删改查的操作
• 与文件的读写交互

1、创建文件

在头文件和源文件的文件夹下面分别创建 workerManger.h 和 workerManger.cpp 文件

2、 头文件实现

在 workerManager.h 中设计管理类

#pragma once  // 防止头文件重复包含
#include <iostream>  // 包含输入输出流头文件
using namespace std;  // 使用标准命名空间

class WorkerManager
{
public:
	// 构造函数
	WorkerManager();
	// 析构函数
	~WorkerManager();
};

3、 源文件实现

在 workerManager.cpp 中将构造函数和析构函数空实现补全

#include "workerManager.h"

WorkerManager::WorkerManager() {}
WorkerManager::~WorkerManager() {}

三、 菜单功能

功能描述：与用户的沟通界面

1、 添加成员函数

在管理类 workerManager.h 中添加成员函数 void Show_Menu();

class WorkerManager
{
public:
	// 构造函数
	WorkerManager();
	// 展示菜单
	void Show_Menu();
	// 析构函数
	~WorkerManager();
};

2、 功能实现

在管理类 workerManager.cpp 中实现 Show_Menu() 函数

void WorkerManager::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;
}

3、 测试菜单功能

在 职工管理系统.cpp 中测试菜单功能

#include <iostream>
using namespace std;
#include "workerManager.h"

int main()
{
	// 实例化管理对象
	WorkerManager wm;
	// 调用成员函数
	wm.Show_Menu();

	system("pause");
	return 0;
}

四、 退出功能

1、 提供功能接口

在 main() 函数中提供分支选择，提供每个功能接口

int main()
{
	WorkerManager wm;
	int choice;
	while (true)
	{
		// 展示菜单
		wm.Show_Menu();
		cout << "请输入您的选择：" << endl;
		cin >> choice;
		switch (choice)
		{
		case 0:  // 退出系统
			break;
		case 1:  // 添加职工
			break;
		case 2:  // 显示职工
			break;
		case 3:  // 删除职工
			break;
		case 4:  // 修改职工
			break;
		case 5:  // 查找职工
			break;
		case 6:  // 排序职工
			break;
		case 7:  // 清空文件
			break;
		default:
			system("cls");
			break;
		}
	}

	system("pause");
	return 0;
}

2、 实现退出功能

在 workerManager.h 中提供退出系统的成员函数 void exitSystem();

在 workerManager.cpp 中提供具体的功能实现

void WorkerManager::exitSystem()
{
	cout << "欢迎下次使用" << endl;
	system("pause");
	exit(0);  // 退出程序 
}

五、 创建职工类

1、 创建职工抽象类

职工分为：普通员工、经理、老板

将三种职工抽象到一个类（worker）中，利用多态管理不同职工种类

职工属性分为：职工编号、职工姓名、职工所在部门

职工的行为：岗位职责信息描述、获取岗位名称

在头文件下，创建文件 worker.h 文件并且添加代码

#pragma once
#include <iostream>
using namespace std;

// 员工抽象类
class Worker
{
public:
	virtual void showInfo() = 0;  // 显示职工信息
	virtual string getDeptName() = 0;  // 返回岗位名称
	int m_Id;  // 职工编号
	string m_Name;  // 职工姓名
	int m_DeptId;  // 部门编号
};

2、 创建普通员工类

在头文件下，创建 employee.h 头文件，并且添加代码

#pragma once
#include "worker.h"
#include <iostream>
using namespace std;

class Employee : public Worker
{
public:
	Employee(int id, string name, int did);
	virtual void showInfo();  // 显示职工信息
	string getDeptName();  // 返回岗位名称
};

在源文件中，创建 employee.cpp，并且添加代码

#include "employee.h"

Employee::Employee(int id, string name, int did)
{
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptId = did;
}
void Employee::showInfo()  // 显示职工信息
{
	cout << "职工编号：" << this->m_Id
		<< "\t职工姓名：" << this->m_Name
		<< "\t职工岗位：" << this->getDeptName()
		<< "\t岗位职责：完成经理布置的任务" << endl;
}
string Employee::getDeptName()  // 返回岗位名称
{
	return string("员工");
}

简单测试

在 职工管理系统.cpp 中添加测试代码

Worker* worker = new Employee(1, "张三", 1);
worker->showInfo();

3、 创建经理类

经理类继承职工抽象类，并重写父类中纯虚函数和普通员工类类似

在头文件和源文件的文件夹下分别创建 manager.h 和 manager.cpp 文件

manager.h 中代码如下

#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

class Manager : public Worker
{
public:
	Manager(int id, string name, int did);
	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 << "职工编号：" << this->m_Id
		<< "\t职工姓名：" << this->m_Name
		<< "\t职工岗位：" << this->getDeptName()
		<< "\t岗位职责：完成老板布置的任务，并下发给员工" << endl;

}
string Manager::getDeptName()
{
	return string("经理");
}

4、 创建老板类

老板类继承职工抽象类，并重写父类中纯虚函数和普通员工类类似

在头文件和源文件的文件夹下分别创建 boss.h 和 boss.cpp 文件

在 boss.h 中添加代码

#pragma once
#include <iostream>
using namespace std;
#include "worker.h"

class Boss : public Worker
{
public:
	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 << "职工编号：" << this->m_Id
		<< "\t职工姓名：" << this->m_Name
		<< "\t职工岗位：" << this->getDeptName()
		<< "\t岗位职责：管理公司所有事务" << endl;
}
string Boss::getDeptName()
{
	return string("老板");
}

5、 代码测试

#include <iostream>
using namespace std;
#include "workerManager.h"
#include "worker.h"
#include "employee.h"
#include "manager.h"
#include "boss.h"

int main()
{
	Worker* worker = NULL;
	worker = new Employee(1, "张三", 1);
	worker->showInfo();
	delete worker;
    
	worker = new Manager(2, "李四", 2);
	worker->showInfo();
	delete worker;
    
	worker = new Boss(3, "Ja", 3);
	worker->showInfo();
	delete worker;
    
	system("pause");
	return 0;
}

六、 添加职工类

功能描述：批量添加职工，并且保存到文件中

1、 功能分析

用户在批量添加时，可能会创建不同种类的员工

如果想将所有不同种类的员工放入到一个数组中，可以将所有员工的指针维护到一个数组里面

如果想在程序中维护这个不定长的数组，可以将数组创建到堆区，并利用 Worker** 的指针维护

2、 功能实现

在 WorkerManager.h 头文件中添加成员属性和成员函数

// 记录文件中的人数
int m_EmpNum;
// 员工数组的指针
Worker** m_EmpArr = NULL;
// 注意要导入 worker 头文件

// 添加职工
void Add_Emp();

workerManager.cpp 实现该函数

#include "employee.h"
#include "manager.h"
#include "boss.h"

// 初始化成员属性
WorkerManager::WorkerManager(){
	// 初始化属性
	this->m_EmpNum = 0;
	this->m_EmpArr = NULL;
}
void WorkerManager::Add_Emp()
{
	int num;  // 保存用户输入数量
	cout << "请输入添加职工的人数：" << endl;
	cin >> num;
	if (num > 0)
	{
		// 添加人数
		// 计算添加空间大小
		int newSize = this->m_EmpNum + num;  // 新空间大小 = 原来的人数 + 添加人数

		// 开辟空间
		Worker** newSpace = new Worker* [newSize];
		// 将原来空间下数据，拷贝到新空间下
		if (this->m_EmpArr)
		{
			for (int i = 0; i < this->m_EmpNum; i++)
			{
				newSpace[i] = this->m_EmpArr[i];
			}
		}
		// 添加数据
		for (int i = 0; i < num; i++)
		{
			int id;
			string name;
			int dSelect;  // 部门选择
			cout << "请输入第" << i + 1 << "个新员工的编号" << endl;
			cin >> id;

			cout << "请输入该新员工的姓名" << endl;
			cin >> name;

			cout << "请选择该新员工的部门" << endl;
			cout << "1、普通员工" << endl;
			cout << "2、经理" << endl;
			cout << "3、老板" << endl;
			cin >> dSelect;

			Worker* worker = NULL;
			switch (dSelect)
			{
			case 1:
				worker = new Employee(id, name, dSelect);
				break;
			case 2:
				worker = new Manager(id, name, dSelect);
				break;
			case 3:
				worker = new Boss(id, name, dSelect);
				break;
			default:
				cout << "请按照要求输入！" << endl;
				break;
			}
			// 将创建的职工指针保存到职工数组中
			newSpace[this->m_EmpNum + i] = worker;
		}
		// 释放原有的空间
		delete[] this->m_EmpArr;
		// 更改新空间的指向
		this->m_EmpArr = newSpace;
		// 更新职工人数
		this->m_EmpNum = newSize;
        this->save();
		cout << "成功添加" << num << "名职工" << endl;
	}
	else
	{
		// 返回
		cout << "输入错误！" << endl;
	}
}

delete[] array; 释放数组空间

七、 文件交互

1、 写文件

功能描述：对文件进行写入

在上一个添加功能中，我们只是将所有的数据添加到了内存中，一旦程序结束就无法保存了。因此，文件管理类中需要一个与文件进行交互的功能，对于文件进行读写操作

1.1 设定文件路径

首先，我们将文件路径，在 workerManager.h 中添加宏常量，并且包含 <fstream> 文件

#include <fstream>
#define FILENAME "empFile.txt"

1.2 成员函数声明

在 workerManager.h 里添加成员函数

// 保存
void save();

1.3 保存功能实现

void WorkerManager::save()
{
	ofstream ofs(FILENAME, ios::out);  
	// 将每个数据写入到文件中
	for (int i = 0; i < this->m_EmpNum; i++)
	{
		ofs << this->m_EmpArr[i]->m_Id << " "
			<< this->m_EmpArr[i]->m_Name << " "
			<< this->m_EmpArr[i]->m_DeptId << endl;
	}
	ofs.close();
}

2、 读文件

功能描述：将文件中的内容读取到程序中

虽然我们实现了添加职工后保存文件的操作，但是每次开始运行程序，并没有将文件中数据读取到程序中

而我们的程序功能中海油清空文件的需求

因此，构造函数初始化数据的情况分为三种

1. 第一次使用，文件未创建
2. 文件存在，但是数据被用户清空
3. 文件存在，并且保存职工所有数据

2.1 文件未创建

在 workerManager.h 中添加新的成员属性 m_FilesEmpty 标志文件是否为空

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

修改 workerManager.cpp 中构造函数代码

WorkerManager::WorkerManager(){
	// 初始化属性
	// 如果文件不存在
	ifstream ifs(FILENAME, ios::in);  // 读文件
	if (!ifs.is_open())
	{
		this->m_EmpNum = 0;
		this->m_EmpArr = NULL;
		this->m_FilesEmpty = true;
		ifs.close();
		return;
	}
}

2.2 文件存在

2.2.1 文件数据为空

在 workerManager.cpp 中的构造函数追加代码

// 文件存在数据为空
char ch;
ifs >> ch;
if (ifs.eof())
{
    this->m_EmpNum = 0;
    this->m_EmpArr = NULL;
    this->m_FilesEmpty = true;
    ifs.close();
    return;
}

ifstream ifs(FILENAME, ios::in);  // 读文件
char ch;
ifs >> ch;
isEmpty = ifs.eof();  // 判断文件是否为空的方法

2.2.2 文件数据存在

2.2.2.1 获取记录的职工人数

在 workerManager.h 中添加成员函数 int get_EmpNum();

// 统计员工人数
int get_EmpNum();

在 workerManager.cpp 实现

int WorkerManager::get_EmpNum()
{
	ifstream ifs(FILENAME, ios::in);
	int id;
	string name;
	int did;
	int num = 0;
	while (ifs >> id && ifs >> name && ifs >> did)
	{
		// 统计人数
		num++;
	}
	return num;
}

2.2.2.2 初始化员工

在 workerManager.h 中添加成员函数void init_Emp();

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

在 workerManager.cpp 中实现

void WorkerManager::init_Emp()
{
    // 初始化员工
	ifstream ifs(FILENAME, ios::in);
	int index = 0;
	int id;
	string name;
	int did;
	while (ifs >> id && ifs >> name && ifs >> did)
	{
		Worker* worker = NULL;
		switch (did)
		{
		case 1:
			worker = new Employee(id, name, did);
			break;
		case 2:
			worker = new Manager(id, name, did);
			break;
		case 3:
			worker = new Boss(id, name, did);
			break;
		}
		this->m_EmpArr[index] = worker;
		index++;
	}
	ifs.close();  // 关闭文件
}

在构造函数追加

// 文件存在且有数据
this->m_EmpNum = this->get_EmpNum();
// 开辟空间
this->m_EmpArr = new Worker * [this->m_EmpNum];
// 将文件中的数据，存到数组中
this->init_Emp();

八、 显示员工

功能描述：显示当前所有员工信息

在 workerManager.h 中添加成员函数void Show_Emp();

// 显示职工信息
void Show_Emp();

在 workerManager.cpp 中实现成员函数

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

九、 删除职工

功能描述：按照职工的编号进行删除职工操作

1、 删除职工函数声明

在 workerManager.h 中添加成员函数void Del_Emp();

// 删除职工函数
void Del_Emp();

2、 职工是否存在函数声明

很多功能都需要用到根据职工是否存在来进行操作，如：删除职工、修改职工、查找职工

因此，添加该函数，以便后续使用

在 workerManager.h 中添加成员函数int IsExist(int id);

// 判断职工是否存在，存在返回索引，不存在返回 -1
int IsExist(int id);  // id查找
int IsExist(string name);  // name查找

3、 职工是否存在函数实现

在 workerManager.h 中添加函数

int WorkerManager::IsExist(int id)
{
	// 判断职工是否存在，存在返回索引，不存在返回 -1
	for (int i = 0; i < this->m_EmpNum; i++)
	{
		if (this->m_EmpArr[i]->m_Id == id)
		{
			return i;
		}
	}
	return -1;  // 没找到返回-1
}
int WorkerManager::IsExist(string name)
{
	for (int i = 0; i < this->m_EmpNum; i++)
	{
		if (this->m_EmpArr[i]->m_Name == name)
		{
			return i;
		}
	}
	return -1;
}

4、 删除职工函数实现

在 workerManager.cpp 中添加函数

void WorkerManager::Del_Emp()
{
	// 删除职工函数
	if (this->m_FilesEmpty)
	{
		cout << "文件不存在或数据为空" << endl;
		return;
	}
	else
	{
		// 按照职工编号删除职工
		int id;
		cout << "请输入要删除的职工编号：" << endl;
		cin >> id;
		int num = this->IsExist(id);
		if (num == -1)  // 说明职工不存在
		{
			cout << "该职工不存在！";
			return;
		}
		else
		{
			for (int i = num; i < m_EmpNum - 1 - num; i++)
			{
				this->m_EmpArr[i] = this->m_EmpArr[i + 1];
			}
			this->m_EmpNum--; // 更新人员个数
			this->save();
			cout << "删除成功" << endl;
			system("pause");
			system("cls");
		}
	}
}

十、 修改职工

功能描述：能够按照职工的编号对职工信息进行修改并保存

1、 函数声明

在 workerManager.h 中添加成员函数void Mod_Emp();

// 修改职工
void Mod_Emp();

2、 函数实现

在 workerManager.cpp 中实现成员函数

void  WorkerManager::Mod_Emp()
{
	if (this->m_FilesEmpty)
	{
		cout << "文件不存在或数据清空" << endl;
	}
	else
	{
		int id;
		cout << "请输入修改职工的编号：" << endl;
		cin >> id;
		int index = this->IsExist(id);
		if (index == -1)
		{
			cout << "该职工不存在" << endl;
		}
		else
		{
			// 职工存在
			delete this->m_EmpArr[index];
			int newId;
			string newName;
			int dSelect;
			cout << "请输入修改内容：" << endl;
			cout << "请输入员工的编号" << endl;
			cin >> newId;

			cout << "请输入该员工的姓名" << endl;
			cin >> newName;

			cout << "请选择该员工的部门" << endl;
			cout << "1、普通员工" << endl;
			cout << "2、经理" << endl;
			cout << "3、老板" << 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:
				cout << "请按照要求输入！" << endl;
				break;
			}
			this->m_EmpArr[index] = worker;  // 重新存储
			cout << "修改成功" << endl;

			this->save();
		}
	}
	system("pause");
	system("cls");
}

十一、 查找职工

功能描述：提供两种查找职工的方式，一种按照职工编号，一种按照职工姓名

1、 查找职工函数声明

在 workerManager.h 中添加成员函数声明void Find_Emp();

// 查找职工
void Find_Emp();

2、 查找职工函数实现

void WorkerManager::Find_Emp()
{
	if (this->m_FilesEmpty)
	{
		cout << "文件为空或不存在" << endl;
	}
	else
	{
		cout << "请输入查找方式：" << endl
			<< "1、 按照职工编号查找" << "\n"
			<< "2、 按照职工姓名查找" << endl;
		int choice;
		cin >> choice;
		switch (choice)
		{
		case 1:
		{
			int id;
			cout << "请输入职工编号：" << endl;
			cin >> id;
			int index = this->IsExist(id);
			if (index == -1)
			{
				cout << "该职工不存在" << endl;
			}
			else
			{
				m_EmpArr[index]->showInfo();
			}
		}
			break;
		case 2:
		{
			cout << "请输入职工姓名：" << endl;
			string name;
			cin >> name;
			int index = this->IsExist(name);
			if (index == -1)
			{
				cout << "该职工不存在" << endl;
			}
			else
			{
				m_EmpArr[index]->showInfo();
			}
		}
			break;
		default:
			cout << "请按照要求输入" << endl;
			break;
		}
	}
    system("pause");
	system("cls");
}

十二、 排序

功能描述：按照职工编号进行排序，排序的顺序由用户指定

1、 函数声明

在 workerManager.h 中添加成员函数void Sort_Emp();

// 排序
void Sort_Emp();

2、 函数实现

在 workerManager.cpp 中添加函数

void WorkerManager::Sort_Emp()
{
	if (this->m_FilesEmpty)
	{
		cout << "文件不存在或文件为空" << endl;
		system("pause");
		system("cls");
		return;
	}
	else
	{

		cout << "请输入排序方式：" << endl
			<< "1、 升序排序" << endl
			<< "2、 降序排序" << endl;
		int choice;
		cin >> choice;
		for (int i = 0; i < this->m_EmpNum; i++)
		{
			int minOrmax = i;
			for (int j = i + 1; j < this->m_EmpNum; j++)
			{
				if (choice == 1)  // 升序
				{
					if (this->m_EmpArr[minOrmax]->m_Id > this->m_EmpArr[j]->m_Id)
					{
						minOrmax = j;
					}
				}
				else
				{
					if (this->m_EmpArr[minOrmax]->m_Id < this->m_EmpArr[j]->m_Id)
					{
						minOrmax = j;
					}
				}
			}
			Worker* temp = m_EmpArr[minOrmax];
			m_EmpArr[minOrmax] = m_EmpArr[i];
			m_EmpArr[i] = temp;
		}
		cout << "排序成功" << endl;
		this->Show_Emp();  // 展示信息
	}
}

选择排序

for (int i = 0; i < this->m_EmpNum; i++)
{
    int minOrmax = i;
    for (int j = i + 1; j < this->m_EmpNum; j++)
    {
        if (choice == 1)  // 升序
        {
            if (this->m_EmpArr[minOrmax]->m_Id > this->m_EmpArr[j]->m_Id)
            {
                minOrmax = j;
            }
        }
        else
        {
            if (this->m_EmpArr[minOrmax]->m_Id < this->m_EmpArr[j]->m_Id)
            {
                minOrmax = j;
            }
        }
    }
    Worker* temp = m_EmpArr[minOrmax];
    m_EmpArr[minOrmax] = m_EmpArr[i];
    m_EmpArr[i] = temp;
}

十三、 清空文件

功能描述：将文件中记录数据清空

1、 清空函数声明

在 workerManager.h 中添加成员函数void Clean_File();

// 清空文件
void Clean_File();

2、 函数实现

在 workerManager.cpp 中实现函数

void WorkerManager::Clean_File()
{
	cout << "确认清空吗？" << endl
		<< "1、 确认" << endl
		<< "2、 取消" << endl;
	int choice;
	cin >> choice;

	switch (choice)
	{
	case 1:
	{
		cout << "清除成功" << endl;
		// 打开模式：ios::trunc，如果存在删除文件并重新创建
		ofstream ofs(FILENAME, ios::trunc);
		ofs.close();

		if (this->m_EmpArr)  // 删除堆区数据
		{
			for (int i = 0; i < m_EmpNum; i++)
			{
				if (this->m_EmpArr[i])
				{
					delete this->m_EmpArr[i];
				}
			}
            // 删除指针
			this->m_EmpNum = 0;
			delete[] this->m_EmpArr; 
			this->m_EmpArr = NULL;
			this->m_FilesEmpty = true;
		}
		break;
	}
	case 2:
		cout << "正在取消" << endl;
		break;
	default:
		cout << "请按要求输入" << endl;
		break;
	}
	system("pause");
	system("cls");
}

目录

1、动态版本

职工管理系统.cpp

worker.h

workerManager.cpp

workerManager.h

employee.cpp

employee.h

manager.cpp

manager.h

boss.h

Boss.cpp

2、静态版本

contact.c

contact.h

3、与动态内存设计通讯录区别

---

要求：
其中包括：

职工编号 姓名 所在部门编号

职工管理系统具有以下功能
1.增加职工信息

2.删除指定职工信息

3.查找职工

4.修改职工信息

5.打印职工信息

6.排序

7.退出系统

1、动态版本

 特点：具有存储功能 -- 简单说就是你下次用还可以找到之前存储的信息

职工管理系统.cpp

#include"workerManager.h"
#include"boss.h"
#include"employee.h"
#include"manager.h"
#include"worker.h"


int main()
{
	int id = 0;
	WorkerManager wm;
	int choice = 0;
	do
	{
		wm.Menu();
		cout << "请输入你要进行的操作：";
		cin >> choice;
		switch (choice)
		{
		case 0://退出系统
			cout << "退出系统成功！" << endl;
			return 0;
			break;
		case 1://添加职工
			wm.Add_Emp();
			break;
		case 2://显示职工
			wm.ShowEmp();
			break;
		case 3://删除职工
			cout << "请输入你要删除的员工编号：";
			cin >> id;
			wm.DeleEmp(id);
			break;
		case 4://修改职工
			cout << "请输入你要修改的员工编号：";
			cin >> id;
			wm.ChangeEmp(id);
			break;
		case 5://查找职工
			cout << "请输入你要查找的员工编号：";
			cin >> id;
			wm.FindEmpP(id);
			break;
		case 6://排序职工
			wm.RankEmp();
			break;
		case 7://清空文件 
			wm.CleanFile();
			break;
		}
	} while (1);



	return 0;
}

worker.h

#include<iostream>
#pragma once//防止头文件重复包含
#include<string>
#include<fstream>
using namespace std;

class Worker
{
public:

	//显示个人信息
	virtual void ShowInfo() = 0;
	
	//获取岗位名称
	virtual string GetDeptName() = 0;

	int m_Id;//职工编号
	string m_Name;//职工姓名
	int m_DeptId;//职工所在部门编号
};

workerManager.cpp

#include"workerManager.h"
#include"employee.h"
#include "manager.h"
#include"boss.h"
#include"worker.h"

//构造函数
WorkerManager::WorkerManager()
{
	ifstream ifs;
	ifs.open(FILENAME, ios::in);

	//文件不存在情况
	if (!ifs.is_open())
	{
		cout << "文件不存在" << endl;

		//初始化人数
		this->m_EmpNum = 0;

		//初始化文件为空标志
		this->m_FileIsEmpty = true;

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

		//关闭文件
		ifs.close();
		return;
	}

	//文件存在，但是没有记录
	char ch;
	ifs >> ch;//右移一个字符去读
	if (ifs.eof())
	{
		cout << "文件内容为空" << endl;

		//初始化人数
		this->m_EmpNum = 0;

		//初始化文件为空标志
		this->m_FileIsEmpty = true;

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

		//关闭文件
		ifs.close();
		return;

	}

	//文件存在 且记录数据
	int num = this->GetNum();

	cout << "当前员工个数为：" << num << endl;

	this->m_EmpNum = num;

	//根据职工数创建数组
	this->m_EmpArray = new Worker*[this->m_EmpNum];

	//初始化职工
	InitEmp();

	/*for (int i = 0; i < this->m_EmpNum; i++)
	{
		cout << "职工号为：" << this->m_EmpArray[i]->m_Id
			<< " 职工名称：" << this->m_EmpArray[i]->m_Name
			<< " 部门编号：" << this->m_EmpArray[i]->m_DeptId << endl;
	}*/


}

//析构函数
WorkerManager::~WorkerManager()
{
	if (this->m_EmpArray != NULL)
	{
		delete[]this->m_EmpArray;
		this->m_EmpArray = NULL;
	}
}

//打印菜单
void WorkerManager::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;

}

//增加职工
void WorkerManager::Add_Emp()
{
	cout << "请输入添加员工的个数：";
	int addnum = 0;
	cin >> addnum;

	if (addnum > 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;

			cout << "请输入第" << i + 1 << "个新员工的编号：" ;
			cin >> id;

			cout << "请输入第" << i + 1 << "个新员工的名字：" ;
			cin >> name;

			cout << "请输入第" << i + 1 << "个新员工的岗位：" << endl;
			cout << "1、职工" << endl;
			cout << "2、经理" << endl;
			cout << "3、老板" << endl;
			cin >> Dselect;


			Worker* worker = NULL;
			switch (Dselect)
			{
			case 1://普通员工
				worker = new Employee(id, name, 1);
				break;
			case 2://经理
				worker = new Manager(id, name, 2);
				break;
			case 3://老板
				worker = new Boss(id, name, 3);
				break;
			default:
				system("cls");
				break;
			}

			newspace[this->m_EmpNum + i] = worker;
		}

		//释放原有的空间
		delete[] this->m_EmpArray;

		//更新新空间的指向
		this->m_EmpArray = newspace;

		//更新新的个数
		this->m_EmpNum = newsize;

		//更新职工不为空标志
		this->m_FileIsEmpty = false;

		cout << "成功添加" << addnum << "名新员工！" << endl;

		this->save();//保存文件
	}

	else
	{
		cout << "输入有误" << endl;
	}
}

//保存职工信息
void WorkerManager::save()
{
	ofstream ofs;
	ofs.open(FILENAME, ios::out);

	for (int i = 0; i < this->m_EmpNum; i++)
	{
		ofs << this->m_EmpArray[i]->m_Id << " "
			<< this->m_EmpArray[i]->m_Name << " "
			<< this->m_EmpArray[i]->m_DeptId << endl;
	}

	ofs.close();
}

//统计人数
int WorkerManager::GetNum()
{
	ifstream ifs;
	ifs.open(FILENAME, ios::in);

	int id;
	string name;
	int did;

	int num = 0;

	while (ifs >> id && ifs >> name&& ifs >> did)
	{
		//记录人数
		num++;
	}
	ifs.close();

	return num;
}

//初始化员工
void WorkerManager::InitEmp()
{
	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 if (did == 3)
		{
			worker = new Boss(id, name, did);//老板
		}

		//把该信息存放在数组中
		this->m_EmpArray[index] = worker;
		index++;
	}
}

//显示职工
void WorkerManager::ShowEmp()
{
	if (this->m_FileIsEmpty )
	{
		cout << "职工信息为空" << endl;
	}
	else
	{
		for (int i = 0; i < this->m_EmpNum; i++)
		{
			//利用多态调用打印
			this->m_EmpArray[i]->ShowInfo();
		}
	}

}

//根据职工编号查找职工
int WorkerManager::FindEmp(int id)
{
	for (int i = 0; i < this->m_EmpNum; i++)
	{
		if (this->m_EmpArray[i]->m_Id == id)
		{
			return i;
		}
	}
	return -1;
}

//根据职工编号查找职工并打印
void WorkerManager::FindEmpP(int id)
{
	int ret =this-> FindEmp(id);
	if (-1 == ret)
	{
		cout << "你要查找的编号不存在！" << endl;
	}

	else
	{
		this->m_EmpArray[ret]->ShowInfo();
	}
}

//删除职工
void WorkerManager::DeleEmp(int id)
{
	int ret =this-> FindEmp(id);
	if (ret == -1)
	{
		cout << "你要删除的员工编号不存在！" << endl;

		return;
	}
	for (int i = ret; i < this->m_EmpNum-1; i++)
	{
		this->m_EmpArray[i] = this->m_EmpArray[i + 1];
	}

	this->m_EmpNum--;

	this->save();//同步到文件中

	cout << "删除成功！" << endl;
}

//修改员工
void WorkerManager::ChangeEmp(int id)
{
	int input = 0;
	string name;
	int m_id;
	int did;
	int ret = this->FindEmp(id);
	if (-1 == ret)
	{
		cout << "你输入的员工编号不存在！" << endl;
	}
	else
	{
		cout << "*******************" << endl;
		cout << "***1、修改编号*****" << endl;
		cout << "***2、修改姓名*****" << endl;
		cout << "***3、修改部门*****" << endl;
		cout << "*******************" << endl;
		cout << "请选择你要进行的操作：";
		cin >> input;
		FindEmpP(input);
		switch (input)
		{
		case 1:
			cout << "请输入修改后的编号：";
			cin >> m_id;
			this->m_EmpArray[ret]->m_Id = m_id;
			break;
		case 2:
			cout << "请输入修改后的姓名：";
			cin >> name;
			this->m_EmpArray[ret]->m_Name = name;
			break;
		case 3:
			cout << "请输入修改后的部门编号：";
			cin >> did;
			this->m_EmpArray[ret]->m_DeptId = did;
			break;
		default:
			cout << "你的输入有误！" << endl;
			break;
		}
		cout << "修改成功" << endl;
	}
}

//排序职工
void WorkerManager::RankEmp()
{
	for (int i = 0; i < this->m_EmpNum - 1; i++)
	{
		for (int j = 0; j < this->m_EmpNum - 1 - i; j++)
		{
			if (this->m_EmpArray[j]->m_Id > this->m_EmpArray[j + 1]->m_Id)
			{
				int m_id = 0;
				m_id = this->m_EmpArray[j]->m_Id;
				this->m_EmpArray[j]->m_Id = this->m_EmpArray[j+1]->m_Id;
				this->m_EmpArray[j + 1]->m_Id = m_id;
			}
		}

	}
	cout << "排序完成" << endl;
}

void WorkerManager::CleanFile()
{
	cout << "是否确认清空？" << endl;
	cout << "1、确认" << endl;
	cout << "2、返回" << endl;

	int input = 0;
	cin >> input;

	if (input == 1)
	{
		//打开模式 ios::trync 如果存在则删除文件并重建
		ofstream ofs(FILENAME, ios::trunc);
		ofs.close();
		
		if (this->m_EmpArray != NULL)
		{
			for (int i = 0; i < this->m_EmpNum; i++)
			{
				if (this->m_EmpArray[i] != NULL)
				{
					delete this->m_EmpArray[i];
				}
			}

			this->m_EmpNum = 0;
			delete[] this->m_EmpArray;
			this->m_EmpArray = NULL;
			this->m_FileIsEmpty = true;
		}

		cout << "清空完成" << endl;
	}
	else
	{
		return;
	}
}

workerManager.h

#pragma once//防止头文件重复包含
#include<iostream>
#include<string>
#include<fstream>
#define FILENAME "empFile.txt"
#include"worker.h"
using namespace std;//使用标准的命名空间

class WorkerManager
{
public:
	WorkerManager();

	int m_EmpNum;//记录文件中的人数个数

	Worker** m_EmpArray;//员工数组的指针

	void Menu();//显示菜单

	void Add_Emp();//添加员工

	void save();//保存文件

	bool m_FileIsEmpty;//标志文件是否为空

	int GetNum();//统计人数

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

	void ShowEmp();//显示职工

	int FindEmp(int id);//查找职工

	void FindEmpP(int id);//查找职工并打印

	void DeleEmp(int id);//删除职工

	void ChangeEmp(int id);//修改员工

	void RankEmp();//排序职工

	void CleanFile();//清空文件

	~WorkerManager();
};

employee.cpp

#include "employee.h"

Employee::Employee(int id, string name, int did)//构造函数传入员工信息
{
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptId = did;
}

//显示个人信息
void Employee::ShowInfo()
{
	cout << "职工编号：" << this->m_Id;
	cout << " 职工姓名：" << this->m_Name;
	cout << " 所在岗位：" << this->GetDeptName();
	cout << " 岗位职责：完成经理交给的任务！" << endl;
}

//获取岗位名称
string Employee::GetDeptName()
{
	return string("员工");
}

employee.h

#include<iostream>
#include<string>
#include<fstream>
#include "worker.h"
using namespace std;

//员工类
class Employee:public Worker
{
public:
	Employee(int id, string name, int did);//构造函数传入员工信息

	//显示个人信息
	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 << "职工编号：" << this->m_Id;
	cout << " 职工姓名：" << this->m_Name;
	cout << " 所在岗位：" << this->GetDeptName();
	cout << " 岗位职责：完成老板交给的任务！" << endl;
}

//获取岗位名称
string Manager::GetDeptName()
{
	return string("经理");
}

manager.h

#include<iostream>
#include<string>
#include<fstream>
#include "worker.h"
using namespace std;

//经理类
class Manager:public Worker
{
public:
	Manager(int id, string name, int did);

	//显示个人信息
	virtual void ShowInfo();

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

boss.h

#include<iostream>
#include<string>
#include<fstream>
#include "worker.h"
using namespace std;

//老板类
class Boss :public Worker
{
public:
	Boss(int id, string name, int did);

	//显示个人信息
	virtual void ShowInfo();

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

Boss.cpp

​
#include<iostream>
#include<string>
#include<fstream>
#include "worker.h"
using namespace std;

//老板类
class Boss :public Worker
{
public:
	Boss(int id, string name, int did);

	//显示个人信息
	virtual void ShowInfo();

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

​

2、静态版本

特点：不具备存储功能 -- 每次运行程序都是一个新的开始 之前存储的信息都会消失 

存放10000个好友信息
其中包括：

名字 电话 性别 地址 年龄

通讯录具有以下功能
1.增加好友信息
2.删除指定名字的好友信息
3.查找好友
4.修改好友信息
5.打印好友信息
6.排序

contact.c

#include "contact.h"

void InitContact(struct Contact* ps)
{
	memset(ps->data,0,sizeof(ps->data));
	ps -> size = 0;
}

void AddContact(struct Contact* ps)
{
	if(ps->size == NUM)
	{
		printf("通讯录存储已满");
	}
	else
	{
		printf("请输入信息\n");
		printf("姓名：");
		scanf("%s",ps->data[ps->size].name);
		printf("\n");
		printf("年龄：");
		scanf("%d",&(ps->data[ps->size].age));//年龄为int型要取地址 
		printf("\n");
		printf("电话：");
		scanf("%s",ps->data[ps->size].tele);
		printf("\n");
	    printf("地址：");
		scanf("%s",ps->data[ps->size].addr);
		printf("\n");	
		printf("性别：");
		scanf("%s",ps->data[ps->size].sex);
		printf("\n");
		
		ps->size++;
		printf("录入信息成功\n");	
	}
}

void ShowContact (struct Contact* ps)
{
	if(ps->size == 0)
	{
		printf("通讯录为空\n");
	}
	else
	{
		int i = 0;
		printf("%-20s\t%-4s\t%-5s\t%-12s\t%-20s\n","名字","年龄","性别","电话","地址"); 
		for(i=0;i<ps->size;i++)
		{
			printf("%-20s\t%-4d\t%-5s\t%-12s\t%-20s\n",ps->data[i].name,
			ps->data[i].age,
			ps->data[i].sex,
			ps->data[i].tele,
			ps->data[i].addr);
		}
	}
}

int FindName(struct Contact* pss,char name[20])
{
	//找到了返回其下标
	int i = 0;
	for(i=0;i<pss->size;i++)
	{
		if(0 == strcmp(pss->data[i].name,name))
	    {
	    	return i;
		} 	
	}
	//找不到返回-1 
	return -1;
}

void DelContact(struct Contact* ps)
{
	char name[20];
	printf("输入删除人的名字：");
	scanf("%s",name);
	//1.查找删除人的位置
    int ret = FindName(ps,name);
	if(ret == -1)
	{
		printf("你输入的名字不存在");
	}
	//2.执行删除
	else
	{
		//删除
		int j = 0;
		for(j=ret;j<ps->size-1;j++)
		{
			ps->data[j] = ps->data[j+1];
		} 
		ps->size--;//个数减一
		printf("删除成功\n"); 
	} 
}

void SearchContact(struct Contact* ps)
{
	printf("请输入查找人的名字：");
	char name[20];
	scanf("%s",name);
    int ret = FindName(ps,name);
	if(ret == -1)
	{
		printf("你输入的名字不存在");
	}
	else
	{
		printf("%-20s\t%-4s\t%-5s\t%-12s\t%-20s\n","名字","年龄","性别","电话","地址");
		printf("%-20s\t%-4d\t%-5s\t%-12s\t%-20s\n",ps->data[ret].name,
		    ps->data[ret].age,
			ps->data[ret].sex,
			ps->data[ret].tele,
			ps->data[ret].addr);
	} 
} 

void ModifyContact(struct Contact* ps)
{
	printf("请输入要修改人的名字：");
	char name[20];
	scanf("%s",name);
	int ret = FindName(ps,name);
	if(ret == -1)
	{
		printf("你输入的名字不存在");
	}
	else
	{
		printf("请输入信息\n");
		printf("姓名：");
		scanf("%s",ps->data[ret].name);
		printf("\n");
		printf("年龄：");
		scanf("%d",&(ps->data[ret].age));//年龄为int型要取地址 
		printf("\n");
		printf("电话：");
		scanf("%s",ps->data[ret].tele);
		printf("\n");
	    printf("地址：");
		scanf("%s",ps->data[ret].addr);
		printf("\n");	
		printf("性别：");
		scanf("%s",ps->data[ret].sex);
		printf("修改完成\n");
	}
}

static int cmp_string(const void* pa ,const void* pb)
{
    char* t1 = (char*)pa;
    char* t2 = (char*)pb;
    return strcmp(pa,pb);
}

void SortContact(struct Contact* ps)
{
	//按照名字进行排序 
	qsort(ps->data,ps->size,sizeof(ps->data[0]),cmp_string);
}

contact.h

#include <stdio.h>
#include <string.h>
#define NUM 1000


struct PeopleInfor
{
	char name[20];
	int age;
	char sex[5];
	char tele[12];
	char addr[10];
};

struct Contact
{
	struct PeopleInfor data[NUM];
	int size;
}; 

enum Option
{
	Exit,
   	Add,
   	Del,
   	Search,
   	Modify,
   	Show,
   	Sort,
};

//声明函数

//初始化通讯录 
void InitContact(struct Contact* ps);

//往通讯录增加一个信息 
void AddContact(struct Contact* ps);

//展示通讯录中的信息 
void ShowContact (struct Contact* ps);

//删除通讯录中某特定信息 
void DelContact(struct Contact* ps);

//查找通讯录中的某特定信息 
void SearchContact(struct Contact* ps);

//查找函数 
int FindName(struct Contact* pss,char name[20]);

//替换指定 
void ModifyContact(struct Contact* ps);

//对通讯录进行排序
void SortContact(struct Contact* ps);

 通讯录.c

#include "address.h"

int main()
{
	//创建通讯录结构体变量
	addressbook adb;

	//初始化通讯录中当前人员个数
	adb.size = 0;

	int input = 0;

	string name;
	do
	{
		menu();
		cout << "请输入：";
		cin >> input;
		switch (input)
		{
		case 0: //0、退出通讯录
			cout << "退出系统成功" << endl;
			return 0;
			break;
		case 1: //1、添加联系人
			AddPerson(&adb);
			break;
		case 2: //2、显示联系人
			ShowPerson(&adb);
			break;
		case 3: //3、删除联系人
			cout << "请输入你要删除人的姓名：";
			cin >> name;
			DelPerson(&adb,name);
			break;
		case 4: //4、查找联系人
			cout << "请输入你要查找人的姓名：";
			cin >> name;
			SerchPerson(&adb, name);
			break;
		case 5: //5、修改联系人
			cout << "请输入你要修改人的姓名：";
			cin >> name;
			ChangePerson(&adb, name);
			break;
		case 6: //6、清空联系人
			ClearPerson(&adb);
			break;
		default:
			cout << "你的输入有误"<<endl;
			break;
		}
	} while (input);

	return 0;
}

3、与动态内存设计通讯录区别

a、改变之处（初始化）

void InitContact(struct Contact* ps)
{
	ps->data = (struct PeopleInfo*) malloc(DEFAULT_SZ*sizeof(struct PeopleInfor));
	if(ps->data == NULL)
	{
	    return;
	}
    ps->size = 0;
	ps->capacity = DEFAULT_SZ;	
}

 struct Contact
{
	PeopleInfor* data;//指向动态申请的空间 用来存放联系人信息 
	int size;//记录当前已有的元素个数
	int capacity;//当前通讯录的最大容量 
};

b、增加判断内存是否储存满

void CheckCapacity(struct Contact* ps)
{
	if(ps->size == ps->capacity)
	{
		//增加空间
		struct PeopleInfor* ptr = (struct PeopleInfor*)realloc(ps->data,(ps->capacity+2)*sizeof(PeopleInfor));
		if(ptr == NULL)
		{
			printf("增容失败\n"); 
		}
		else
		{
			ps->data = ptr;
			ps->capacity = ps->capacity + 2;
			printf("增容成功\n"); 
		}
	}
}

c、程序结束 释放内存

void DestroyContact(struct Contact* ps)
{
	free(ps->data);
	ps->data = NULL;
} 

参考博客：链接

代码结构：

以下是所有代码：
头文件：
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"

//Boss类
class Boss :public Worker {
public:
	//构造函数
	Boss(int id, string name, int did);

	//显示个人信息
	void showInfo();

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

manager.h

#pragma once
#include<iostream>
using namespace std;
#include "worker.h"

//经理类
class Manager :public Worker {
public:
	//构造函数
	Manager(int id, string name, int did);

	//显示个人信息
	void showInfo();

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

employee.h

//普通员工文件
#pragma once
#include<iostream>
using namespace std;
#include "worker.h"

class Employee :public Worker {
public:
	//构造函数
	Employee(int id, string name, int did);

	//显示个人信息
	void showInfo();

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

workerManager.h

#pragma once   //放置头文件重复包含
#include<iostream>   //包含输入输出流头文件
using namespace std;  //使用标准命名空间
#include"worker.h"
#include"employee.h"
#include"manager.h"
#include"boss.h"

#include<fstream>
#define FILENAME "empFile.txt"

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

	//展示菜单
	void Show_Menu();

	//退出系统
	void ExitSystem();

	//记录职工人数
	int m_EmpNum;

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

	//添加职工
	void Add_Emp();

	//保存文件
	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();

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

源文件
boss.cpp

#include<iostream>
using namespace std;
#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 << "职工编号：" << this->m_Id
		<< "\t职工姓名：" << this->m_Name
		<< "\t岗位：" << this->getDeptName()
		<< "\t岗位职责：管理公司所有事务" << endl;
}

//获取岗位名称
string Boss::getDeptName() {
	return string("老板");
}

manager.cpp

#include<iostream>
using namespace std;
#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 << "职工编号：" << this->m_Id
		<< "\t职工姓名：" << this->m_Name
		<< "\t岗位：" << this->getDeptName()
		<< "\t岗位职责：完成老板交给的任务，并且下发任务给员工" << endl;
}

//获取岗位名称
string Manager::getDeptName() {
	return string("经理");
}

employee.cpp

#include<iostream>
using namespace std;
#include "employee.h"

//构造函数
Employee::Employee(int id, string name, int did) {
	this->m_Id = id;
	this->m_Name = name;
	this->m_DeptId = did;
}

//显示个人信息
void Employee::showInfo() {
	cout << "职工编号：" << this->m_Id
		<< "\t职工姓名：" << this->m_Name
		<< "\t岗位：" << this->getDeptName()
		<< "\t岗位职责：完成经理交给的任务" << endl;
}

//获取岗位名称
string Employee::getDeptName() {
	return string("员工");
}

workerManager.cpp

#include "workerManager.h"

WorkerManager::WorkerManager() {
	//1、文件不存在
	ifstream ifs;
	ifs.open(FILENAME, ios::in);   //读文件

	if (!ifs.is_open()) {
		cout << "文件不存在!" << endl;
		//初始化属性
		//初始化记录人数
		this->m_EmpNum = 0;
		//初始化数组指针
		this->m_EmpArray = NULL;
		//初始化文件是否为空
		this->m_FileIsEmpty = true;
		ifs.close();
		return;
	}

	//2、文件存在  但是为空
	char ch;
	ifs >> ch;
	if (ifs.eof()) {
		//文件为空
		cout << "文件为空!" << endl;
		//初始化记录人数
		this->m_EmpNum = 0;
		//初始化数组指针
		this->m_EmpArray = NULL;
		//初始化文件是否为空
		this->m_FileIsEmpty = true;
		ifs.close();
		return;
	}

	//3、当文件存在  且有数据
	int num = this->get_EmpNum();
	cout << "职工人数为：" << 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 << "职工编号：" << this->m_EmpArray[i]->m_Id
	//		<< "\t姓名：" << this->m_EmpArray[i]->m_Name
	//		<< "\t部门编号：" << this->m_EmpArray[i]->m_DeptId << endl;
	//}
	
}

//展示菜单
void WorkerManager::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;
}

//退出系统
void WorkerManager::ExitSystem(){
	cout << "欢迎下次使用..." << endl;
	system("pause");
	exit(0);   //退出程序
}

//添加职工
void WorkerManager::Add_Emp() {
	cout << "请输入添加职工数量：" << endl;

	int addNum = 0;   //保存用户的输入数量
	cin >> addNum;

	if (addNum > 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;  //部门选择

			cout << "请输入第" << i + 1 << "个新职工编号：" << endl;
			cin >> id;

			cout << "请输入第" << i + 1 << "个新职工姓名：" << endl;
			cin >> name;

			cout << "请选择该职工岗位：" << endl;
			cout << "1、普通职工" << endl;
			cout << "2、经理" << endl;
			cout << "3、老板" << endl;
			cin >> dSelect;

			Worker* worker = NULL;
			switch (dSelect)
			{
			case 1:
				worker = new Employee(id, name, 1);
				break;
			case 2:
				worker = new Manager(id, name, 2);
				break;
			case 3:
				worker = new Boss(id, name, 3);
				break;
			default:
				break;
			}
			//将创建的职工职责，保存到数组中
			newSpace[this->m_EmpNum + i] = worker;
		}

		//释放原有的空间
		delete[] this->m_EmpArray;

		//更改新空间的指向
		this->m_EmpArray = newSpace;

		//更新新的职工人数
		this->m_EmpNum = newSize;

		//更新职工不为空标志
		this->m_FileIsEmpty = false;

		//提示添加成功
		cout << "成功添加" << addNum << "名新职工！" << endl;

		//成功添加后，保存到文件中
		this->save();

	}
	else {
		cout << "输入数据有误！" << 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 << 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);
		}
		this->m_EmpArray[index] = worker;
		index++;
	}

	//关闭文件
	ifs.close();
}

//显示职工
void WorkerManager::Show_Emp() {
	//判断文件是否为空
	if (this->m_FileIsEmpty) {
		cout << "文件不存在或者记录为空！" << 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 << "文件不存在或记录为空！" << endl;
	}
	else {
		//按照职工编号删除
		cout << "请输入想要删除职工编号：" << endl;
		int id = 0;
		cin >> id;

		int index = this->IsExist(id);

		if (index != -1) {   //说明职工存在
			//数据前移
			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 << "删除成功！" << endl;
		}
		else {
			cout << "删除失败，未找到该职工！" << endl;
		}

		//按任意键清屏
		system("pause");
		system("cls");
	}
}

//判断职工 是否存在  如果存在返回职工所在数组中的位置，不存在返回-1
int WorkerManager::IsExist(int id) {
	int index = -1;
	for (int i = 0; i < this->m_EmpNum; i++) {
		if (this->m_EmpArray[i]->m_Id == id) {
			//找到职工
			index = i;

			break;
		}
	}
	return index;
}

//修改职工
void WorkerManager::Mod_Emp() {
	if (this -> m_FileIsEmpty) {
		cout << "文件不存在或记录为空！" << endl;
	}
	else {
		cout << "请输入修改职工的编号：" << 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 << "查到：" << id << "号职工，请输入新的职工号：" << endl;
		cin >> newId;

		cout << "请输入新姓名：" << endl;
		cin >> newName;

		cout << "请输入岗位：" << endl;
		cout << "1、普通职工" << endl;
		cout << "2、经理" << endl;
		cout << "3、老板" << 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 << "修改成功！" << endl;

		//保存到文件中
		this->save();
	}
	else {
		cout << "修改失败！查无此人！" << endl;
	}

	//按任意键清屏
	system("pause");
	system("cls");
}

//查找职工
void WorkerManager::Find_Emp() {
	if (this->m_FileIsEmpty) {
		cout << "文件不存在或记录为空！" << endl;
	}
	else {
		cout << "请选择查找的方式：" << endl;
		cout << "1、按职工编号查找：" << endl;
		cout << "2、按职工姓名查找：" << endl;

		int select = 0;
		cin >> select;

		if (select == 1) {
			//按照编号查
			int id;
			cout << "请输入要查找的编号：" << endl;
			cin >> id;

			int ret = IsExist(id);
			if (ret != -1) {
				//找到职工
				cout << "查找成功！该职工的信息如下：" << endl;
				this->m_EmpArray[ret]->showInfo();
			}
			else {
				cout << "查找失败！查无此人！" << endl;
			}
		}
		else if (select == 2) {
			//按照姓名查
			string name;
			cout << "请输入查找的姓名：" << endl;
			cin >> name;

			//加入判断查找是否查到的标志
			bool flag = false;   

			for (int i = 0; i < m_EmpNum; i++) {
				if (this->m_EmpArray[i]->m_Name == name) {
					cout << "查找成功！职工编号为：" << this->m_EmpArray[i]->m_Id
						<< "号职工信息如下：" << endl;

					flag = true;

					//调用显示信息接口
					this->m_EmpArray[i]->showInfo();
				}
			}
			if (flag == false) {
				cout << "查找失败！查无此人！" << endl;
			}
		}
		else {
			cout << "输入的编号有误！" << endl;
		}
	}

	//清屏
	system("pause");
	system("cls");
}

//按照职工编号排序
void WorkerManager::Sort_Emp() {
	if (this->m_FileIsEmpty) {
		cout << "文件不存在或记录为空！" << endl;

		system("pause");
		system("cls");
	}
	else {
		cout << "请选择排序方式：" << endl;
		cout << "1、按职工编号升序" << endl;
		cout << "2、按职工编号降序" << 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;
			}
		}

		cout << "排序成功！排序后的结果为：" << endl;
		this->save();
		this->Show_Emp();
	}
}

//清空文件
void WorkerManager::Clean_File() {
	cout << "确定清空？" << endl;
	cout << "1、确定" << endl;
	cout << "2、返回" << endl;

	int select = 0;
	cin >> select;

	if (select == 1) {
		//清空文件
		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;
			this->m_EmpNum = 0;
			this->m_FileIsEmpty = true;
		}

		cout << "清空成功！" << endl;
	}

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

WorkerManager::~WorkerManager() {
	if (this->m_EmpArray != NULL) {
		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;
	}
}

职工管理系统.cpp

#include<iostream>
using namespace std;
#include "workerManager.h"
#include "worker.h"
#include "employee.h"
#include"manager.h"
#include"boss.h"

int main() {
	//测试代码：
	//Worker* worker = NULL;
	//worker = new Employee(1, "张三", 1);
	//worker->showInfo();
	//delete worker;

	//worker = new Manager(2, "李四", 2);
	//worker->showInfo();
	//delete worker;

	//worker = new Boss(3, "王五", 3);
	//worker->showInfo();
	//delete worker;

	//return 0;


	//实例化管理者对象
	WorkerManager wm;

	int choice = 0;  //用来存储用户的选项
	while (true) {
		//调用展示菜单成员函数
		wm.Show_Menu();

		cout << "请输入您的选择：" << endl;
		cin >> choice;   //接收选项

		switch (choice) {
		case 0:       //退出系统
			wm.ExitSystem();
			break;
		case 1:       //增加职工
			wm.Add_Emp();
			break;
		case 2:       //显示职工
			wm.Show_Emp();
			break;
		case 3:       //删除职工
			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;
		}
	}

	system("pause");    //按任意键继续
	return 0;
}