devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++职工管理系统：看这一篇就够了，有详细的步骤及流程_职工管理系统c++编程

作者：木道寻08 | 2024-07-31 21:42:36

赞

踩

职工管理系统c++编程

目录

职工管理系统

1、管理系统需求

2、创建项目

3、创建管理类

 3.1创建文件

3.2 头文件实现

3.3 源文件实现 

4、菜单功能

4.1 添加成员函数

4.2 菜单功能实现

4.3 测试菜单功能

5、退出功能 

5.1 提供功能接口

5.2 实现退出功能 

5.3测试功能

6、创建职工类 

6.1 创建职工抽象类

6.2 创建普通员工类

6.3 创建经理类

6.4 创建老板类

6.5 测试多态

 7、添加职工

7.1 功能分析

7.2 功能实现

8、文件交互-写文件

8.1 设定文件路径

8.2 成员函数声明

8.3 保存文件功能实现

8.4 保存文件功能测试

​编辑

 9、文件交互-读文件

9.1 文件未创建

 9.2 文件存在且数据为空

9.3 文件存在且保存职工数据

9.3.1 获取记录的职工人数

9.3.2 初始化数组

10、显示职工

10.1 显示职工函数声明

10.2 显示职工函数实现

10.3 测试显示职工

 11、删除职工

11.1 删除职工函数声明

11.2 职工是否存在函数声明

11.3 职工是否存在函数实现

11.4 删除职工函数实现

11.5 测试删除职工

12、修改职工

12.1 修改职工函数声明

12.2 修改职工函数实现

12.3 测试删除职工

13、查找职工

13.1 查找职工函数声明

13.2 查找职工函数实现

13.3 测试查找职工

14、排序 

14.1排序函数声明

14.2 排序函数实现

14.3 测试排序功能

15、清空文件

15.1 清空函数声明

15.2 清空函数实现

15.3 测试功能

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

职工管理系统

1、管理系统需求

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

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

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

普通员工职责：完成经理交给的任务

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

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

管理系统中需要实现的功能如下:

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

系统界面效果图如下:

2、创建项目

3、创建管理类

管理类负责的内容如下:

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

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

3.2 头文件实现

在workerManager.h中设计管理类
代码如下:

  1. #pragma once //防止重复包含头文件
  2. #include <iostream> //包含iostream头文件
  3. #include <string> //包含string头文件
  4. using namespace std; //使用命名空间std
  5.  
  6.  
  7. class WorkerManager {
  8. public:
  9. 	WorkerManager(); //构造函数
  10. 	~WorkerManager(); //析构函数
  11. };
3.3 源文件实现 

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

  1. #include "workerManager.h"
  2.  
  3. WorkerManager::WorkerManager(){//构造函数
  4.  
  5. }
  6.  
  7. WorkerManager::~WorkerManager(){//析构函数
  8.  
  9. }

4、菜单功能

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

4.1 添加成员函数

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

  1. #pragma once //防止重复包含头文件
  2. #include <iostream> //包含iostream头文件
  3. #include <string> //包含string头文件
  4. using namespace std; //使用命名空间std
  5.  
  6. class WorkerManager {
  7. public:
  8. 	WorkerManager(); //构造函数
  9.  
  10. 	// 展示菜单函数
  11. 	void Show_Menu();
  12.  
  13. 	~WorkerManager(); //析构函数
  14. };
4.2 菜单功能实现

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

  1. #include "workerManager.h"
  2.  
  3. WorkerManager::WorkerManager(){//构造函数
  4.  
  5. }
  6.  
  7. // 展示菜单
  8. void WorkerManager::Show_Menu() {
  9.     cout << "*******************************************" << endl;
  10.     cout << "*********欢迎使用职工管理系统***********" << endl;
  11.     cout << "***********0.退出管理系统*************" << endl;
  12.     cout << "***********1.新增职工信息*************" << endl;
  13.     cout << "***********2.显示职工信息*************" << endl;
  14.     cout << "***********3.删除离职职工*************" << endl;
  15.     cout << "***********4.修改职工信息*************" << endl;
  16.     cout << "***********5.查找职工信息*************" << endl;
  17.     cout << "***********6.按照编号排序*************" << endl;
  18.     cout << "***********7.清空所以文档*************" << endl;
  19. }
  20.  
  21. WorkerManager::~WorkerManager(){//析构函数
  22.  
  23. }
4.3 测试菜单功能

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

  1. #include <iostream> //包含iostream头文件
  2. #include <string> //包含string头文件
  3. using namespace std; //使用命名空间std
  4. #include "workerManager.h"
  5.  
  6. int main() {
  7. 	// 实例化管理者对象
  8. 	WorkerManager manager;
  9.  
  10. 	// 调用展示菜单函数
  11. 	manager.Show_Menu();
  12.  
  13. 	system("pause"); //暂停程序，等待用户输入
  14. 	return 0; //程序正常退出
  15. }

效果图

5、退出功能 

5.1 提供功能接口

在main函数中提供分支选择，提供每个功能接口
代码:

  1. #include <iostream> //包含iostream头文件
  2. #include <string> //包含string头文件
  3. using namespace std; //使用命名空间std
  4. #include "workerManager.h"
  5.  
  6. int main() {
  7. 	// 实例化管理者对象
  8. 	WorkerManager manager;
  9.  
  10. 	int choice = 0; // 选择的选项
  11.  
  12. 	// 循环读取用户输入的选项
  13. 	while (true) {
  14. 		manager.Show_Menu(); // 显示菜单
  15. 		cout << "请输入选项：";
  16. 		cin >> choice; // 读取用户输入的选项
  17.  
  18. 		switch (choice) {
  19. 			case 0: // 退出系统
  20. 				manager.exit_system(); // 调用exit_system函数
  21. 				break;
  22. 			case 1: // 新增职工
  23. 				break;
  24. 			case 2: // 显示职工
  25. 				break;
  26. 			case 3: // 删除职工
  27. 				break;
  28. 			case 4: // 修改职工信息
  29. 				break;
  30. 			case 5: // 查找职工
  31. 				break;
  32. 			case 6: // 排序职工
  33. 				break;
  34. 			case 7: // 清空
  35. 				break;
  36. 			default: // 输入错误的选项
  37. 				cout << "输入错误的选项！" << endl;
  38. 				system("cls");//清屏
  39. 				break;
  40. 		}
  41. 	}
  42. 		
  43. 	// 调用展示菜单函数
  44. 	manager.Show_Menu();
  45.  
  46. 	system("pause"); //暂停程序，等待用户输入
  47. 	return 0; //程序正常退出
  48. }
5.2 实现退出功能 

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

  1. class WorkerManager {
  2. public:
  3. 	WorkerManager(); //构造函数
  4.  
  5. 	// 展示菜单函数
  6. 	void Show_Menu();
  7.  
  8. 	// 退出系统函数
  9. 	void exit_system();
  10.  
  11. 	~WorkerManager(); //析构函数
  12. };

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

  1. // 退出系统函数
  2. void WorkerManager::exit_system() {
  3.     cout << "**********退出系统**********" << endl;
  4.     cout << "********欢迎下次使用**********" << endl;
  5.     system("pause");//暂停程序
  6.     exit(0);//退出系统
  7. }
5.3测试功能

在main函数分支0 选项中，调用退出程序的接口

  1. case 0: // 退出系统
  2. 	manager.exit_system(); // 调用exit_system函数
  3. 	break;

效果图

6、创建职工类 

6.1 创建职工抽象类

职工的分类为:普通员工、经理、老板

将三种职工抽象到一个类(worker)中,利用多态管理不同职工种类

职工的属性为:职工编号、职工姓名、职工所在部门编号

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

头文件文件夹下 创建文件worker.h 文件并且添加如下代码

  1. #pragma once // 防止重复包含头文件
  2. #include <string> // 包含string类
  3. #include <iostream> // 包含iostream类
  4. using namespace std; // 使用命名空间std
  5.  
  6. // 定义职工抽象基类
  7. class Worker {
  8. public:
  9. 	// 显示职工信息
  10. 	virtual void showInfo() = 0;
  11. 	// 获取岗位名称
  12. 	virtual string getDeptName() = 0;
  13.  
  14. 	int m_ID; // 职工ID
  15. 	string m_Name; // 职工姓名
  16. 	string m_Dept_ID; // 职工部门ID
  17. };
6.2 创建普通员工类

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

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

employee.h中代码如下

  1. #pragma once // 防止重复包含头文件
  2. #include <string> // 包含string类
  3. #include <iostream> // 包含iostream类
  4. using namespace std; // 使用命名空间std
  5. #include "worker.h"
  6.  
  7. // 创建员工类
  8. class Employee : public Worker {
  9. public:
  10.     // 构造函数
  11.     Employee(string m_Name, int m_ID,string m_Dept_ID);
  12. 	// 显示职工信息
  13. 	virtual void showInfo();
  14. 	// 获取岗位名称
  15. 	virtual string getDeptName();
  16. };

employee.cpp中代码如下

  1. #include "employee.h"
  2.  
  3. Employee::Employee(int id, string name, int dId) {
  4. 	this->m_Name = name;
  5. 	this->m_ID = id;
  6. 	this->m_Dept_ID = dId;
  7. }
  8. // 显示职工信息
  9. void Employee::showInfo() {
  10. 	cout << "职工编号：" << this->m_ID 
  11. 		<< "\t职工姓名：" << this->m_Name 
  12. 		<< "\t部门编号：" << this->m_Dept_ID
  13. 		<< "\t岗位名称：" << this->getDeptName() 
  14. 		<< "\t岗位职责：完成经理交办的工作" << endl;
  15. }
  16. // 获取部门名称
  17. string Employee::getDeptName() {
  18. 	return string("普通员工");
  19. }
6.3 创建经理类

经理类继承职工抽象类，并重写父类中纯虚函数，和普通员工类似；在头文件和源文件的文件夹下分别创建manager.h和 manager.cpp文件
manager.h中代码如下:

  1. #pragma once // 防止重复包含头文件
  2. #include <string> // 包含string类
  3. #include <iostream> // 包含iostream类
  4. using namespace std; // 使用命名空间std
  5. #include "worker.h"
  6.  
  7. // 定义Manager类 - 继承自Worker类
  8. class Manager : public Worker {
  9. public:
  10. 	// 构造函数
  11. 	Manager(int id, string name, int dId); // 传入id、姓名、部门id
  12. 	// 显示职工信息
  13. 	virtual void showInfo();
  14. 	// 获取岗位名称
  15. 	virtual string getDeptName();
  16. };

manager.CPP中代码如下:

  1. #include "manager.h"
  2.  
  3. Manager::Manager(int id, string name, int dId) {
  4.     this->m_ID = id;
  5.     this->m_Name = name;
  6.     this->m_Dept_ID = dId;
  7. }
  8.  
  9. // 显示职工信息
  10. void Manager::showInfo() {
  11. 	cout << "职工编号：" << this->m_ID 
  12. 		<< "\t职工姓名：" << this->m_Name 
  13. 		<< "\t部门编号：" << this->m_Dept_ID
  14. 		<< "\t岗位名称：" << this->getDeptName() 
  15. 		<< "\t岗位职责：完成老板交办的工作，下发任务给员工" << endl;
  16. }
  17. // 获取部门名称
  18. string Manager::getDeptName() {
  19. 	return string("经理");
  20. }
6.4 创建老板类

老板类继承职工抽象类，并重写父类中纯虚的数，和普通员工类似；在头文件和源文件的文件夹下分别创建boss.h和 boss.cpp文件
boss.h中代码如下:

  1. #pragma once // 防止重复包含头文件
  2. #include <string> // 包含string类
  3. #include <iostream> // 包含iostream类
  4. using namespace std; // 使用命名空间std
  5. #include "worker.h"
  6.  
  7. // 定义Boss类 - 继承自Worker类
  8. class Boss : public Worker {
  9. public:
  10.     // 构造函数
  11.     Boss(int id, string name, int dId);
  12. 	// 显示职工信息
  13. 	virtual void showInfo();
  14. 	// 获取岗位名称
  15. 	virtual string getDeptName();
  16. };

boss.cpp中代码如下:

  1. #include "boss.h"
  2.  
  3. Boss::Boss(int id, string name, int dId) {
  4.     this->m_ID = id;
  5.     this->m_Name = name;
  6.     this->m_Dept_ID = dId;
  7. }
  8. // 显示职工信息
  9. void Boss::showInfo() {
  10. 	cout << "职工编号：" << this->m_ID 
  11. 		<< "\t职工姓名：" << this->m_Name 
  12. 		<< "\t部门编号：" << this->m_Dept_ID
  13. 		<< "\t岗位名称：" << this->getDeptName() 
  14. 		<< "\t岗位职责：管理公司所有事务" << endl;
  15. }
  16. // 获取部门名称
  17. string Boss::getDeptName() {
  18. 	return string("总裁");
  19. }
6.5 测试多态

在职工管理系统.cpp中添加测试函数，并且运行能够产生多态
测试代码如下

  1. void test() {
  2. 	Worker* worker = NULL;//定义指向Worker类的指针
  3. 	worker = new Employee(1, "张三",1);
  4. 	worker->showInfo();
  5. 	delete worker;
  6.  
  7. 	worker = new Manager(2, "李四", 2);
  8. 	worker->showInfo();
  9. 	delete worker;
  10.  
  11. 	worker = new Boss(3, "王武", 3);
  12. 	worker->showInfo();
  13. 	delete worker;
  14. }

 7、添加职工

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

7.1 功能分析

分析:
用户在批是创建时，可能会创建不同种类的职工；如果想将所有不同种类的员工都放入到一个数组中，可以将所有员工的指针维护到一个数组里；如果想在程序中维护这个不定长度的数组，可以将数组创建到堆区，并利用Worker **的指针维护

7.2 功能实现

在WokerManager.h头文件中添加成员属性

  1. class WorkerManager {
  2. public:
  3. 	WorkerManager(); //构造函数
  4.  
  5. 	// 展示菜单函数
  6. 	void Show_Menu();
  7.  
  8. 	// 退出系统函数
  9. 	void Exit_System();
  10.  
  11. 	// 记录员工人数
  12. 	int Record_Employee_Number;
  13.  
  14. 	// 员工数组指针
  15. 	Worker** Employee_Array;
  16.  
  17. 	// 添加员工
  18. 	void Add_Employee();
  19.  
  20. 	~WorkerManager(); //析构函数
  21. };

在WorkerManager构造函数中初始化属性

  1. WorkerManager::WorkerManager(){//构造函数
  2.     // 初始化属性
  3.     this->Record_Employee_Number = 0;
  4.  
  5.     // 初始化职工数组指针
  6.     this->Employee_Array = NULL;
  7. }

在workerManager.h中添加成员函数

  1. class WorkerManager {
  2. public:
  3. 	WorkerManager(); //构造函数
  4.  
  5. 	// 展示菜单函数
  6. 	void Show_Menu();
  7.  
  8. 	// 退出系统函数
  9. 	void Exit_System();
  10.  
  11. 	// 记录员工人数
  12. 	int Record_Employee_Number;
  13.  
  14. 	// 员工数组指针
  15. 	Worker** Employee_Array;
  16.  
  17. 	// 添加员工
  18. 	void Add_Employee();
  19.  
  20. 	~WorkerManager(); //析构函数
  21. };

workerManager.cpp中实现该函数

  1. // 新增职工信息函数
  2. void WorkerManager::Add_Employee() {
  3.     cout << "**********新增职工信息**********" << endl;
  4.     cout << "请输入增加职工数量：" << endl;
  5.  
  6.     int add_num = 0;
  7.     cin >> add_num;
  8.  
  9.     if (add_num > 0) {
  10.         // 计算新空间大小
  11.         int new_size = this->Record_Employee_Number + add_num;
  12.         // 申请新空间
  13.         Worker** new_Space = new Worker* [new_size];
  14.  
  15.         // 将原空间下的数据存放到新空间
  16.         if (this->Record_Employee_Number != NULL) {
  17.             for (int i = 0; i < this->Record_Employee_Number; i++) {
  18.                 new_Space[i] = this->Employee_Array[i];
  19.             }
  20.         }
  21.  
  22.         // 输入新数据
  23.         for (int i = 0; i < add_num; i++) {
  24.             int id;
  25.             string name;
  26.             int dSelect;
  27.  
  28.             cout << "请输入第" << i + 1 << "个职工编号：" << endl;
  29.             cin >> id;
  30.             cout << "请输入第" << i + 1 << "个职工姓名：" << endl;
  31.             cin >> name;
  32.  
  33.             cout << "请选择职工类型：" << endl;
  34.             cout << "1.员工" << endl;
  35.             cout << "2.经理" << endl;
  36.             cout << "3.老板" << endl;
  37.             cin >> dSelect;
  38.  
  39.             // 根据选择创建不同类型的职工对象
  40.             Worker* worker = NULL;
  41.             switch (dSelect) {
  42.             case 1://员工
  43.                 worker = new Employee(id, name, 1);
  44.                 break;
  45.             case 2://经理
  46.                 worker = new Manager(id, name, 2);
  47.                 break;
  48.             case 3://老板
  49.                 worker = new Boss(id, name, 3);
  50.                 break;
  51.             default:
  52.                 cout << "输入错误，请重新输入！" << endl;
  53.                 break;
  54.             }
  55.  
  56.             // 将新职工对象存放到新空间
  57.             new_Space[this->Record_Employee_Number + i] = worker;
  58.         }
  59.  
  60.         // 释放原空间
  61.         delete[] this->Employee_Array;
  62.  
  63.         // 指向新空间
  64.         this->Employee_Array = new_Space;
  65.  
  66.         // 记录职工数量
  67.         this->Record_Employee_Number = new_size;
  68.  
  69.         cout << "新增职工" << add_num << "个成功！" << endl;
  70.     }
  71.     else {
  72.         cout << "新增职工数量必须大于0！" << endl;
  73.     }
  74.     // 暂停；清屏回到菜单
  75.     system("pause");//暂停程序
  76.     system("cls");//清屏
  77. }

8、文件交互-写文件

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

8.1 设定文件路径

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

  1. #include <fstream> //包含fstream头文件
  2. #define FILE_NAME "employeeFile.txt" //定义文件名
8.2 成员函数声明

在workerManager.h中类里添加成员函数 void Save_File()

  1. class WorkerManager {
  2. public:
  3. 	// 保存文件
  4. 	void Save_File();
  5. };
8.3 保存文件功能实现

在workerManager.cpp

  1. // 保存文件
  2. void WorkerManager::Save_File() {
  3.     cout << "**********保存职工信息**********" << endl;
  4.  
  5.     ofstream ofs;// 定义文件输出流
  6.     ofs.open(FILE_NAME, ios::out);//用输出的方式打开文件，写文件
  7.  
  8.     for (int i = 0; i < this->Record_Employee_Number; i++) {//遍历职工数组
  9.         ofs << this->Employee_Array[i]->m_ID
  10.             << " " << this->Employee_Array[i]->m_Name
  11.             << " " << this->Employee_Array[i]->m_Dept_ID << endl;
  12.     }
  13.  
  14.     ofs.close();// 关闭文件输出流
  15.  
  16.     cout << "保存成功！" << endl;
  17. }
8.4 保存文件功能测试

在添加职工功能中添加成功后添加保存文件函数

  1. // 释放原空间
  2. delete[] this->Employee_Array;
  3.  
  4. // 指向新空间
  5. this->Employee_Array = new_Space;
  6.  
  7. // 记录职工数量
  8. this->Record_Employee_Number = new_size;
  9.  
  10. cout << "新增职工" << add_num << "个成功！" << endl;
  11.  
  12. // 保存文件
  13. this->Save_File();

 9、文件交互-读文件

功能描述：将文件中的内容读取到程序中
虽然我们实现了添加职工后保存到文件的操作，但是每次开始运行程序，并没有将文件中数据读取到程序中；而我们的程序功能中还有清空文件的需求

因此构造函数初始化数据的情况分为三种
1.第一次使用，文件未创建
2.文件存在，但是数据被用户清空
3.文件存在，并且保存职工的所有数据

9.1 文件未创建

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

  1. class WorkerManager {
  2. public:
  3. 	// 标志文件是否为空
  4. 	bool Is_File_Empty;
  5. };

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

  1. WorkerManager::WorkerManager(){//构造函数
  2.      初始化属性
  3.     //this->Record_Employee_Number = 0;
  4.  
  5.      初始化职工数组指针
  6.     //this->Employee_Array = NULL;
  7.  
  8.  
  9.     ifstream ifs;// 定义文件输入流
  10.     ifs.open(FILE_NAME, ios::in);//用输入的方式打开文件，读文件
  11.     // 文件不存在情况
  12.     if (!ifs.is_open()) {
  13.         cout << "文件不存在！" << endl;//
  14.         this->Record_Employee_Number = 0;// 初始化
  15.         this->Is_File_Empty = true;// 初始化文件为空
  16.         this->Employee_Array = NULL;// 指针置空
  17.         ifs.close();// 关闭文件输入流
  18.         return;
  19.     }
  20. }

删除文件后，测试文件不存在时初始化数据功能

 9.2 文件存在且数据为空

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

  1. WorkerManager::WorkerManager(){//构造函数
  2.      初始化属性
  3.     //this->Record_Employee_Number = 0;
  4.  
  5.      初始化职工数组指针
  6.     //this->Employee_Array = NULL;
  7.  
  8.     //1、文件不存在情况
  9.     ifstream ifs;// 定义文件输入流
  10.     ifs.open(FILE_NAME, ios::in);//用输入的方式打开文件，读文件
  11.     // 文件不存在情况
  12.     if (!ifs.is_open()) {
  13.         cout << ">>>> 文件不存在！" << endl;
  14.         this->Record_Employee_Number = 0;// 初始化
  15.         this->Is_File_Empty = true;// 初始化文件为空
  16.         this->Employee_Array = NULL;// 指针置空
  17.         ifs.close();// 关闭文件输入流
  18.         return;
  19.     }
  20.  
  21.  
  22.     //2、文件存在，并且没有记录
  23.     char ch;
  24.     ifs >> ch;
  25.     if(ifs.eof()) {
  26.         cout << ">>>> 文件为空！" << endl;
  27.         this->Record_Employee_Number = 0;
  28.         this->Is_File_Empty = true;
  29.         this->Employee_Array = NULL;
  30.         ifs.close();
  31.         return;
  32.     }
  33.     else {
  34.         ifs.close();
  35.         this->Is_File_Empty = false;
  36.         return;
  37.     }
  38. }

将文件创建后清空文件内容，并测试该情况下初始化功能

我们发现文件不存在或者为空清空 Is_File_Empty判断文件是否为空的标志都为真，那何时为假?成功添加职工后，应该更改文件不为空的标志

在 void WorkerManager::Add_Employee()成员图数中添加:

  1. // 释放原空间
  2. delete[] this->Employee_Array;
  3.  
  4. // 指向新空间
  5. this->Employee_Array = new_Space;
  6.  
  7. // 记录职工数量
  8. this->Record_Employee_Number = new_size;
  9.  
  10. // 标志文件是否为空
  11. this->Is_File_Empty = false;
  12.  
  13. cout << "新增职工" << add_num << "个成功！" << endl;
  14.  
  15. // 保存文件
  16. this->Save_File();
9.3 文件存在且保存职工数据
9.3.1 获取记录的职工人数

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

  1. class WorkerManager {
  2. public:
  3.  
  4. 	// 统计文件中的员工数量
  5. 	int Get_Employee_Number();
  6. };

workerManager.cpp中实现

  1. // 统计文件中的员工数量
  2. int WorkerManager::Get_Employee_Number() {
  3.     ifstream ifs;
  4.     ifs.open(FILE_NAME, ios::in);//用输入的方式打开文件，读文件
  5.     int id;
  6.     string name;
  7.     int dId;
  8.     int count = 0;
  9.     while(ifs >> id && ifs >> name && ifs >> dId) {
  10.         count++;//记录职工数量
  11.     }
  12.     ifs.close();
  13.     return count;
  14. }

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

  1.     //3、文件存在，有记录
  2.     // 统计文件中的职工数量
  3.     int count = this->Get_Employee_Number();
  4.     cout << ">>>> 文件存在，职工数量为：" << count << endl;
  5.     this->Record_Employee_Number = count; // 更新成员属性
9.3.2 初始化数组

根据职工的数据以及职工数据，初始化workerManager中的Worker**m_EmpArray 指针

在WorkerManager.h中添加成员函数 void Init_Employee_Array();

  1. class WorkerManager {
  2. public:
  3. 	// 初始化员工数组
  4. 	void Init_Employee_Array();
  5. };

在WorkerManager.cpp中实现

  1. // 初始化员工数组
  2. void WorkerManager::Init_Employee_Array() {
  3.     cout << ">>>> 初始化员工数组**********" << endl;
  4.     ifstream ifs;
  5.     ifs.open(FILE_NAME, ios::in);//用输入的方式打开文件，读文件
  6.     int id;
  7.     string name;
  8.     int dId;
  9.     int index = 0;
  10.     while(ifs >> id && ifs >> name && ifs >> dId) {//遍历文件中的职工信息
  11.         // 根据部门编号创建不同类型的职工对象
  12.         Worker* worker = NULL;
  13.         if (dId == 1) {//员工
  14.             worker = new Employee(id, name, dId);
  15.         }
  16.         else if (dId == 2) {//经理
  17.             worker = new Manager(id, name, dId);
  18.         }
  19.         else if (dId == 3) {//老板
  20.             worker = new Boss(id, name, dId);
  21.         }
  22.         else {
  23.             cout << "输入错误，请重新输入！" << endl;
  24.             break;
  25.         }
  26.         // 将职工对象存放到数组
  27.         this->Employee_Array[index] = worker;
  28.         index++;
  29.     }
  30.     ifs.close();
  31. }

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

  1.  
  2. this->Employee_Array = new Worker* [this->Record_Employee_Number];//申请内存空间
  3. // 将文件中的职工信息存放到职工数组
  4. this->Init_Employee_Array();// 
  5.  
  6. // 测试
  7. for (int i = 0; i < Record_Employee_Number; i++) {
  8.     cout << "职工编号：" << this->Employee_Array[i]->m_ID
  9.         << "；职工姓名：" << this->Employee_Array[i]->m_Name
  10.         << "；部门编号：" << this->Employee_Array[i]->m_Dept_ID << endl;
  11. }

10、显示职工

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

10.1 显示职工函数声明

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

  1. // 显示职工函数
  2. void Show_Employee();
10.2 显示职工函数实现

在workerManager.cpp中实现成员的数void Show_Employee();

  1. // 显示职工函数
  2. void WorkerManager::Show_Employee() {
  3.     cout << "**********显示职工信息**********" << endl;
  4.  
  5.     if (this->Is_File_Empty) {//文件为空
  6.         cout << "文件不存在或为空！" << endl;
  7.     }
  8.     else {
  9.         for (int i = 0; i < Record_Employee_Number; i++) {//遍历职工数组
  10.             // 利用多态特性，调用不同类型的职工对象的显示信息函数
  11.             this->Employee_Array[i]->showInfo();
  12.         }
  13.     }
  14.     // 暂停；清屏回到菜单
  15.     system("pause");//暂停程序
  16.     system("cls");//清屏
  17. }
10.3 测试显示职工

在main函数分支2 选项中，调用显示职工接口

  1. case 0: // 退出系统
  2. 	manager.Exit_System(); // 调用exit_system函数
  3. 	break;
  4. case 1: // 新增职工
  5. 	manager.Add_Employee(); // 调用Add_Employee函数
  6. 	break;
  7. case 2: // 显示职工
  8. 	manager.Show_Employee(); // 调用Show_Employee函数

 11、删除职工

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

11.1 删除职工函数声明

在workerManpger.h中添加成员函数void Delete_Employee();

  1. 	// 删除职工函数
  2. 	void Delete_Employee();
  3.  
  4. 	// 职工是否存在
  5. 	int Is_Employee_Exist(int id);
11.2 职工是否存在函数声明

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

因此添加该公告函数，以便后续调用

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

  1. 	// 删除职工函数
  2. 	void Delete_Employee();
  3.  
  4. 	// 职工是否存在
  5. 	int Is_Employee_Exist(int id);
11.3 职工是否存在函数实现

在workerManager.cpp中实现成员函数Is_Employee_Exist(int id);

  1. // 职工是否存在
  2. int WorkerManager::Is_Employee_Exist(int id) {
  3.     int index = -1;
  4.     for (int i = 0; i < this->Record_Employee_Number; i++) {
  5.         if (this->Employee_Array[i]->m_ID == id) {
  6.             index = i;
  7.             break;
  8.         }
  9.     }
  10.     return index;
  11. }
11.4 删除职工函数实现

在workerManager.cpp中实现成员函数 void Delete_Employee();

  1. // 删除职工函数
  2. void WorkerManager::Delete_Employee() {
  3.     if (this->Is_File_Empty) {
  4.         cout << "文件不存在或为空！" << endl;
  5.     }
  6.     else {
  7.         cout << "请输入要删除的职工编号：" << endl;
  8.         int id = 0;
  9.         cin >> id;
  10.  
  11.         int index = this->Is_Employee_Exist(id);//判断职工是否存在
  12.  
  13.         if (index != -1) {//存在
  14.             // 数据结构：删除元素后，后面的元素前移一位，所以需要将后面的元素前移一位
  15.             for (int i = index; i < this->Record_Employee_Number - 1; i++) {
  16.                 this->Employee_Array[i] = this->Employee_Array[i + 1];
  17.             }
  18.             this->Record_Employee_Number--;//更新职工数量
  19.             cout << "删除成功！" << endl;
  20.             // 保存文件
  21.             this->Save_File();
  22.         }
  23.         else {
  24.             cout << "删除失败，不存在该职工！" << endl;
  25.         }
  26.     }
  27.  
  28.     // 暂停；清屏回到菜单
  29.     system("pause");//暂停程序
  30.     system("cls");//清屏
  31. }
11.5 测试删除职工

在main函数分支3 选项中，调用删除职工接口

  1. case 3: // 删除职工
  2. 	manager.Delete_Employee(); // 调用Delete_Employee函数
  3. 	break;

12、修改职工

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

12.1 修改职工函数声明

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

  1. 	// 修改职工函数
  2. 	void Modify_Employee();
12.2 修改职工函数实现

在workerManager.cpp中实现成员函数 void Modify_Employee();

  1. // 修改职工函数
  2. void WorkerManager::Modify_Employee() {
  3.     cout << "**********修改职工信息**********" << endl;
  4.     if (this->Is_File_Empty) {
  5.         cout << "文件不存在或为空！" << endl;
  6.     }
  7.     else {
  8.         cout << "请输入要修改的职工编号：" << endl;
  9.         int id;
  10.         cin >> id;
  11.  
  12.         int result = this->Is_Employee_Exist(id);//判断职工是否存在
  13.  
  14.         if (result != -1) {//存在
  15.             delete this->Employee_Array[result];//释放原职工对象
  16.  
  17.             int new_id = 0;
  18.             string new_name = "";
  19.             int dSelect = 0;
  20.  
  21.             cout << "查到" << id << "号职工，请输入新的职工编号：" << endl;
  22.             cin >> new_id;
  23.             cout << "请输入新的职工姓名：" << endl;
  24.             cin >> new_name;
  25.  
  26.             cout << "请选择职工类型：" << endl;
  27.             cout << "1.员工" << endl;
  28.             cout << "2.经理" << endl;
  29.             cout << "3.老板" << endl;
  30.             cin >> dSelect;
  31.  
  32.             // 根据选择创建不同类型的职工对象
  33.             Worker* worker = NULL;
  34.             switch (dSelect) {
  35.             case 1://员工
  36.                 worker = new Employee(new_id, new_name, 1);
  37.                 break;
  38.             case 2://经理
  39.                 worker = new Manager(new_id, new_name, 2);
  40.                 break;
  41.             case 3://老板
  42.                 worker = new Boss(new_id, new_name, 3);
  43.                 break;
  44.             default:
  45.                 cout << "输入错误，请重新输入！" << endl;
  46.                 break;
  47.             }
  48.  
  49.             // 将新职工对象存放到数组
  50.             this->Employee_Array[result] = worker;
  51.  
  52.             cout << "修改成功！" << endl;
  53.             // 保存文件
  54.             this->Save_File();
  55.         }
  56.         else {
  57.             cout << "修改失败，不存在该职工！" << endl;
  58.         }
  59.     }
  60.  
  61.     // 暂停；清屏回到菜单
  62.     system("pause");//暂停程序
  63.     system("cls");//清屏
  64. }
12.3 测试删除职工

在main函数分支4 选项中，调用修改职工接口

  1. case 4: // 修改职工信息
  2. 	manager.Modify_Employee(); // 调用Modify_Employee函数

13、查找职工

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

13.1 查找职工函数声明

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

  1. 	// 查找职工函数
  2. 	void Find_Employee();
13.2 查找职工函数实现

在workerManager.cpp中实现成员函数void Find_Employee();

  1. // 查找职工函数
  2. void WorkerManager::Find_Employee() {
  3.     cout << "**********查找职工信息**********" << endl;
  4.     if (this->Is_File_Empty) {
  5.         cout << "文件不存在或为空！" << endl;
  6.     }
  7.     else {
  8.         cout << "请输入要查找的方式：" << endl;
  9.         cout << "1.按编号查找" << endl;
  10.         cout << "2.按姓名查找" << endl;
  11.         int select = 0;
  12.         cin >> select;
  13.  
  14.         if (select == 1) {//按编号查找
  15.             cout << "请输入要查找的职工编号：" << endl;
  16.             int id;
  17.             cin >> id;
  18.  
  19.             int result = this->Is_Employee_Exist(id);//判断职工是否存在
  20.  
  21.             if (result != -1) {//存在
  22.                 
  23.                 this->Employee_Array[result]->showInfo();
  24.             }
  25.             else {
  26.                 cout << "不存在该职工！" << endl;
  27.             }
  28.         }
  29.         else if (select == 2) {//按姓名查找
  30.             cout << "请输入要查找的职工姓名：" << endl;
  31.             string name;
  32.             cin >> name;
  33.  
  34.             bool flag = false;
  35.             for (int i = 0; i < this->Record_Employee_Number; i++) {
  36.                 if (this->Employee_Array[i]->m_Name == name) {
  37.                     cout << "查找成功，职工编号： " << Employee_Array[i]->m_ID
  38.                         << " ；职工姓名： " << name << endl;
  39.                     
  40.                     flag = true;
  41.                     this->Employee_Array[i]->showInfo();
  42.                 }
  43.             }
  44.             if (flag == false) {
  45.                 cout << "不存在该职工！" << endl;
  46.             }
  47.         }
  48.         else {
  49.             cout << "输入错误，请重新输入！" << endl;
  50.         }
  51.     }
  52.     // 暂停；清屏回到菜单
  53.     system("pause");//暂停程序
  54.     system("cls");//清屏
  55. }
13.3 测试查找职工

在main函数分支5 选项中，调用查找职工接口

  1. case 5: // 查找职工
  2. 	manager.Find_Employee(); // 调用Find_Employee函数

14、排序 

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

14.1排序函数声明

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

  1. 	// 排序
  2. 	void Sort_Employee();
14.2 排序函数实现

在workerManager.cpp中实现成员函数void Sort_Employee();

  1. // 排序
  2. void WorkerManager::Sort_Employee() {
  3.     cout << "**********按照编号排序**********" << endl;
  4.     if (this->Is_File_Empty) {
  5.         cout << "文件不存在或为空！" << endl;
  6.         system("pause");//暂停程序
  7.         system("cls");//清屏
  8.     }
  9.     else {
  10.         // 显示排序前的结果
  11.         cout << "排序前：" << endl;
  12.         for (int i = 0; i < this->Record_Employee_Number; i++) {
  13.             this->Employee_Array[i]->showInfo();
  14.         }
  15.         cout << "选择排序方式：" << endl;
  16.         cout << "1.职工编号升序" << endl;
  17.         cout << "2.职工编号降序" << endl;
  18.         int select = 0;
  19.         cin >> select;
  20.  
  21.         if (select == 1) {//升序
  22.             for (int i = 0; i < this->Record_Employee_Number - 1; i++) {
  23.                 for (int j = i + 1; j < this->Record_Employee_Number; j++) {
  24.                     if (this->Employee_Array[i]->m_ID > this->Employee_Array[j]->m_ID) {
  25.                         Worker* temp = this->Employee_Array[i];
  26.                         this->Employee_Array[i] = this->Employee_Array[j];
  27.                         this->Employee_Array[j] = temp;
  28.                     }
  29.                 }
  30.             }
  31.             cout << "排序成功！" << endl;
  32.             // 显示排序后的结果
  33.             for (int i = 0; i < this->Record_Employee_Number; i++) {
  34.                 this->Employee_Array[i]->showInfo();
  35.             }
  36.             // 保存排序后的结果
  37.             this->Save_File();
  38.         }
  39.         else if (select == 2) {//降序
  40.             for (int i = 0; i < this->Record_Employee_Number - 1; i++) {
  41.                 for (int j = i + 1; j < this->Record_Employee_Number; j++) {
  42.                     if (this->Employee_Array[i]->m_ID < this->Employee_Array[j]->m_ID) {
  43.                         Worker* temp = this->Employee_Array[i];
  44.                         this->Employee_Array[i] = this->Employee_Array[j];
  45.                         this->Employee_Array[j] = temp;
  46.                     }
  47.                 }
  48.             }
  49.             cout << "排序成功！" << endl;
  50.             // 显示排序后的结果
  51.             for (int i = 0; i < this->Record_Employee_Number; i++) {
  52.                 this->Employee_Array[i]->showInfo();
  53.             }
  54.             // 保存排序后的结果
  55.             this->Save_File();
  56.         }
  57.         else {
  58.             cout << "输入错误，请重新输入！" << endl;
  59.         }
  60.     }
  61.     // 暂停；清屏回到菜单
  62.     system("pause");//暂停程序
  63.     system("cls");//清屏
  64. }
14.3 测试排序功能

在main函数分支6 选项中，调用排序职工接口

  1. case 6: // 排序职工
  2. 	manager.Sort_Employee(); // 调用Sort_Employee函数

15、清空文件

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

15.1 清空函数声明

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

  1. 	// 清空文件
  2. 	void Clear_File();
15.2 清空函数实现

在workerManager.cpp中实现函数 void Clear_File();

  1. // 清空文件
  2. void WorkerManager::Clear_File() {
  3.     cout << "**********清空文件**********" << endl;
  4.     cout << "是否确认清空？" << endl;
  5.     cout << "1.确认" << endl;
  6.     cout << "2.取消" << endl;
  7.     int select = 0;
  8.     cin >> select;
  9.  
  10.     if (select == 1) {//确认
  11.         // 释放职工数组空间
  12.         delete[] this->Employee_Array;
  13.         this->Employee_Array = NULL;
  14.         this->Record_Employee_Number = 0;
  15.         this->Is_File_Empty = true;
  16.         cout << "文件已清空！" << endl;
  17.         // 保存文件
  18.         this->Save_File();
  19.     }
  20.     else if (select == 2) {//取消
  21.         cout << "取消清空！" << endl;
  22.     }
  23.     else {
  24.         cout << "输入错误，请重新输入！" << endl;
  25.     }  
  26.     // 暂停；清屏回到菜单
  27.     system("pause");//暂停程序
  28.     system("cls");//清屏
  29. }
15.3 测试功能

在main函数分支7 选项中，调用清空文件接口

  1. case 7: // 清空文件
  2. 	manager.Clear_File(); // 调用Clear_File函数

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号