1 管理系统要求

职工管理系统可以用来管理公司内所有员工的信息，本教程主要利用C++来实现一个基于多态的职工管理系统

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

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

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

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

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

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

2 创建项目

创建项目步骤如下：

  • 创建新项目
  • 添加文件

2.1 创建项目

打开Visual studio后，点击创建新项目，创建新的C++项目

image-20220123124340461 image-20220123125134404 image-20220123125917692

2.2 创建文件

右键源文件，选择添加->新建项

image-20220123130442955

给C++文件起个名称，然后点击添加即可。

image-20220123130813668

3 创建管理类

管理类负责的内容如下：

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

3.1 创建文件

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

workerManager.h

1
2
3
4
5
6
7
8
9
#pragma once  //防止头文件重复包含
#include<iostream>  //包含输入输出流头文件
using namespace std;  //使用标准命名空间

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

workerManager.cpp

1
2
3
4
5
6
7
8
9
#include"workerManager.h"

WorkerManager::WorkerManager() {

}

WorkerManager::~WorkerManager() {

}

4 菜单功能

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

4.1 添加成员函数

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

image-20220212224622220

4.2 菜单功能实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
}

4.3 测试菜单功能

在controlsystem.cpp中测试菜单功能

代码：

1
2
3
4
5
6
7
8
9
10
11
12
#include<iostream>
using namespace std;
#include"workerManager.h"

int main() {
	WorkerManager wm;//实例化管理者对象

	wm.Show_Menu();//调用展示菜单成员函数

	system("pause");
	return 0;
}

运行效果图：

image-20220212230614288

5 退出功能

5.1 提供功能接口

在main函数中体哦概念股分支选择，提供每个功能接口

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<iostream>
using namespace std;
#include"workerManager.h"

int main() {
	WorkerManager wm;//实例化管理者对象
	int choice = 0;
	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;
}

5.2 实现退出功能

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

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

1
2
3
4
5
void WorkerManager::exitSystem() {
	cout << "欢迎下次使用" << endl;
	system("pause");
	exit(0);
}

5.3 测试功能

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

image-20220212232411609

6 创建职工类

6.1 创建职工抽象类

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#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;//部门编号
};

6.2 创建普通员工类

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

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

employee.h中代码如下：

1
2
3
4
5
6
7
8
9
10
11
#pragma once
#include<iostream>
using namespace std;
#include"worker.h"

class Employee :public Worker {
public:
	Employee(int id,string name,int dId);//构造函数
	virtual void showInfo();//显示个人信息
	virtual string getDeptName();//获取岗位名称
};

employee.cpp中代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#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("员工");
}

6.3 创建经理类

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

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

manager.h代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#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代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include"manager.h"
#include<string>

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("经理");
}

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

boss.h代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
#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代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include"boss.h"
#include<string>

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("总裁");
}

7 添加职工

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

7.1 功能分析

分析：

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

如果想将所有不同种类的员工都放入到一个数组中，可以将所有员工的指针维护到一个数组中，如果想在程序中维护这个不定长度的数组，可以将数组创建到堆区，并利用Worker**的指针维护

image-20220213104849463

7.2 功能实现

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

1
2
3
4
5
//记录文件中的人数个数
int m_EmpNum;

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

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

1
2
3
4
5
6
WorkerManager::WorkerManager(){
	//初始化人数
	this->m_EmpNum = 0;
	//初始化数组指针
	this->m_EmpArray = NULL;
}

在workerManager.h中添加成员函数

1
2
//添加职工
void Add_Emp();

workerManager.cpp中实现该函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include"workerManager.h"
#include"employee.h"
#include"worker.h"
#include"manager.h"
#include"boss.h"

WorkerManager::WorkerManager() {
	this->m_EmpNum = 0;
	this->m_EmpArray;
}

WorkerManager::~WorkerManager() {

}

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);
			case 2:
				worker = new Manager(id, name, 2);
			case 3:
				worker = new Boss(id, name, 3);
			default:
				break;
			}
			//将创建的职工职责，保存到数组中
			newSpace[this->m_EmpNum + i] = worker;
		}
		//释放原有的空间
		delete[] this->m_EmpArray;
		//修改新空间指向
		this->m_EmpArray = newSpace;
		//更新新的职工人数
		this->m_EmpNum = newSize;
		//提示添加成功
		cout << "成功添加" << addNum << "名新职工！" << endl;
	}
	else {
		cout << "数据有误。" << endl;
	}
	system("pause");//按任意键后
	system("cls");//清屏回到上级目录
}

8 文件交互 - 写文件

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

​ 在上一个添加功能中，我们只是将所有的数据添加到了内存中，一旦程序结束就无法保存了

​ 因此文件管理类中需要一个与文件进行交互的功能，对于文件进行读写操作

8.1 设定文件路径

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

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

8.2 成员函数声明

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

1
2
//保存文件
void save();

8.3 保存文件功能实现

1
2
3
4
5
6
7
8
9
10
11
12
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();//关闭文件
}

8.4 保存文件功能测试

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

image-20220213174506769

再运行文件，添加职工

image-20220213174631810

在同级目录下多出文件，并且保存了添加的信息。

image-20220213183010518

9 文件交互 - 读文件

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

虽然我们实现了添加职工后爆粗到文件的操作，但是每次开始运行程序，并没有将文件中数据读取到程序中，而我们的程序功能中还有清空文件的需求，因此构造函数初始化数据的清空分为三种

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

9.1 文件未创建

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
WorkerManager::WorkerManager() {
	//文件不存在
	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;
	}
}

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

9.2 文件存在且数据为空

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
WorkerManager::WorkerManager() {
	//文件不存在
	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;
	}
	char ch;
	ifs >> ch;
	if (ifs.eof()) {
		cout << "文件为空！" << endl;
		this->m_EmpNum = 0;
		this->m_EmpArray = NULL;
		this->m_FileIsEmpty = true;
		ifs.close();
		return;
	}
}

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

我们发现文件不存在或者为空，清空m_FileIsEmpty判断文件是否为空的标志都为真，那何时为假？

成功添加职工后，应该更改文件不为空的标志

在void WorkerManager::Add_Emp()成员函数中添加：

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

image-20220213223956477

9.3 文件为空且保存职工数据

9.3.1 获取记录的职工人数

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

1
2
//统计人数
int get_EmpNum;

workerManager.cpp中实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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++;
	}
	ifs.close();
	return num;
}

9.3.2 初始化数组

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

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

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

在WorkerManager.cpp中实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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;
		//根据不同的部门Id创建不同对象
		if (dId == 1) { //1普通员工
			worker = new Employee(id, name, dId);
		}
		else if (dId == 2) { //2经理
			worker = new Manager(id, name, dId);
		}
		else { //总裁
			worker = new Boss(id, name, dId);
		}
		//存放在数组中
		this->m_EmpArray[index] = worker;
		index++;
	}
    ifs.close();
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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
			<< " 姓名：" << this->m_EmpArray[i]->m_Name
			<< " 部门编号：" << this->m_EmpArray[i]->m_DeptID << endl;
	}
}

10 显示职工

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

10.1 显示职工函数声明

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

1
2
//显示职工
void Show_Emp();

10.2 显示职工函数实现

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

1
2
3
4
5
6
7
8
9
10
11
12
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");//按任意键清屏
}

10.3 测试显示职工

image-20220214003737834

11 删除职工

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

11.1 删除职工函数声明

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

1
2
//删除职工
void Del_Emp();

11.2 职工是否存在函数声明

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

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

1
2
//按照职工编号判断职工是否存在，若存在，返回职工在数组中位置，不存在返回-1
int IsExist(int id);

11.3 职工是否存在函数实现

在workManager.cpp中实现成员函数int IsExist(int id);

1
2
3
4
5
6
7
8
9
10
11
int WorkerManager::IsExist(int id) { //判断职工是否存在，如果存在返回职工所在数组中的位置，不存在返回-1
	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;
}

11.4 删除职工函数实现

在workManager.cpp中实现成员函数void Del_Emp();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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) { //说明职工存在，并且要删除index位置上的员工
			for (int i = index; i < this->m_EmpNum - 1; i++) {
				this->m_EmpArray[i] = this->m_EmpArray[i + 1];
			}
			this->m_EmpNum--;//更新数组中记录人员个数
			this->save();//数据同步更新到文件中
		}
		else {
			cout << "删除失败，未找到该职工！" << endl;
		}
		system("pause");
		system("cls");
	}
}

11.5 测试删除职工

在main函数switch分支3中，调用删除职工：

image-20220214125125296

测试1-删除不存在职工的情况

image-20220214125539975

测试2-删除职工存在的情况

image-20220214125422157

查看文件中信息，再次核实员工已被完全删除。

image-20220214125613696

至此，删除职工功能实现完毕。

12 修改职工

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

12.1 修改职工函数声明

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

1
2
//修改职工
void Mod_Emp();

12.2 修改职工函数实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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) { //说明职工存在，并且要删除ret位置上的员工
			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;
			}
		}
		else {
			cout << "修改失败，查无此人！" << endl;
		}

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

13 查找职工

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

13.1 查找职工函数声明

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

1
2
//查找职工
void Find_Emp();

13.2 查找职工函数实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
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 (m_EmpArray[i]->m_Name == name) {
					cout << "查找成功，职工编号为："
						<< 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");
	}
}

14 排序

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

14.1 排序函数声明

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

1
2
//排序职工
void Sort_Emp();

14.2 排序函数实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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 < m_EmpNum; j++) {
				if (select == 1) {
					if (m_EmpArray[minOrMax]->m_ID > m_EmpArray[j]->m_ID) {
						minOrMax = j;
					}
				}
				else {
					if (m_EmpArray[minOrMax]->m_ID < m_EmpArray[j]->m_ID) {
						minOrMax = j;
					}
				}
			}
			if (i != minOrMax) {
				Worker* temp = m_EmpArray[i];
				m_EmpArray[i] = m_EmpArray[minOrMax];
				m_EmpArray[minOrMax] = temp;
			}
		}
		cout << "排序成功，排序后结果为：" << endl;
		this->save();
		this->Show_Emp();
	}
}

15 清空文件

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

15.1 清空函数声明

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

1
2
//清空文件
void Clean_File();

15.3 清空函数实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void WorkerManager::Clean_File() {
	cout << "确认清空？" << endl;
	cout << "1.确认" << endl;
	cout << "2.返回" << endl;

	int select = 0;
	cin >> select;

	if (select == 1) {
		//打开模式 ios::trunc 如果存在删除文件并重新创建
		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 != NULL) {
					delete this->m_EmpArray[i];//把每一个对象清理干净
				}
			}
			this->m_EmpNum = 0;
			delete[] this->m_EmpArray;//删除堆区数组指针
			this->m_EmpArray = NULL;
			this->m_FileIsEmpty = true;
		}
		cout << "清空成功" << endl;
	}
	system("pause");
	system("cls");
}

15.3 测试清空文件

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

image-20220214182502476

测试：确认清空文件

image-20220214182637594

image-20220214182726104

打开文件，里面数据已确保清空，该功能慎用！

image-20220214182937151

案例制作完毕！

代码

主函数 controlsystem.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#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;
	
	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://删除职工
		{
			//测试代码：
			//int ret = wm.IsExist(5);
			//if (ret != -1) {
			//	cout << "职工存在。" << endl;
			//}
			//else {
			//	cout << "职工不存在。" << endl;
			//}
			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;
}

workerManager.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#pragma once  //防止头文件重复包含
#include<iostream>  //包含输入输出流头文件
using namespace std;  //使用标准命名空间
#include"worker.h"
#include<fstream>
#define FILENAME "empFile.txt"

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

	void Show_Menu(); //展示菜单

	void exitSystem();//退出系统

	void save();//保存文件

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

	void Show_Emp();//显示职工

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

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

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

	void Mod_Emp();//修改职工

	void Find_Emp();//查找职工

	void Sort_Emp();//排序职工

	void Clean_File();//清空文件

	~WorkerManager(); //析构函数

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

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

	void Add_Emp();
};

workerManager.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
#include"workerManager.h"
#include"employee.h"
#include"worker.h"
#include"manager.h"
#include"boss.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
	//		<< " 姓名：" << 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::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);
			case 2:
				worker = new Manager(id, name, 2);
			case 3:
				worker = new Boss(id, name, 3);
			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++;
	}
	ifs.close();
	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;
		//根据不同的部门Id创建不同对象
		if (dId == 1) { //1普通员工
			worker = new Employee(id, name, dId);
		}
		else if (dId == 2) { //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) { //说明职工存在，并且要删除index位置上的员工
			for (int i = index; i < this->m_EmpNum - 1; i++) {
				this->m_EmpArray[i] = this->m_EmpArray[i + 1];
			}
			this->m_EmpNum--;//更新数组中记录人员个数
			this->save();//数据同步更新到文件中
		}
		else {
			cout << "删除失败，未找到该职工！" << endl;
		}
		system("pause");
		system("cls");
	}
}
int WorkerManager::IsExist(int id) { //判断职工是否存在，如果存在返回职工所在数组中的位置，不存在返回-1
	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) { //说明职工存在，并且要删除ret位置上的员工
			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;
			}
		}
		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 (m_EmpArray[i]->m_Name == name) {
					cout << "查找成功，职工编号为："
						<< 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 < m_EmpNum; j++) {
				if (select == 1) {
					if (m_EmpArray[minOrMax]->m_ID > m_EmpArray[j]->m_ID) {
						minOrMax = j;
					}
				}
				else {
					if (m_EmpArray[minOrMax]->m_ID < m_EmpArray[j]->m_ID) {
						minOrMax = j;
					}
				}
			}
			if (i != minOrMax) {
				Worker* temp = m_EmpArray[i];
				m_EmpArray[i] = m_EmpArray[minOrMax];
				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) {
		//打开模式 ios::trunc 如果存在删除文件并重新创建
		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 != NULL) {
					delete this->m_EmpArray[i];//把每一个对象清理干净
				}
			}
			this->m_EmpNum = 0;
			delete[] this->m_EmpArray;//删除堆区数组指针
			this->m_EmpArray = NULL;
			this->m_FileIsEmpty = true;
		}
		cout << "清空成功" << endl;
	}
	system("pause");
	system("cls");
}

worker.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#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;//部门编号
};

employee.h

1
2
3
4
5
6
7
8
9
10
11
#pragma once
#include<iostream>
using namespace std;
#include"worker.h"

class Employee :public Worker {
public:
	Employee(int id,string name,int dId);//构造函数
	virtual void showInfo();//显示个人信息
	virtual string getDeptName();//获取岗位名称
};

employee.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include"employee.h"
#include<string>

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("员工");
}

manager.h

1
2
3
4
5
6
7
8
9
10
11
12
#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include"manager.h"
#include<string>

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("经理");
}

boss.h

1
2
3
4
5
6
7
8
9
10
11
12
#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include"boss.h"
#include<string>

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("总裁");
}