机房管理系统c++

墨下名

已于 2024-06-21 14:45:37 修改

阅读量307

点赞数 10

文章标签： c++ 前端

于 2024-06-20 17:27:11 首次发布

本文链接：https://blog.csdn.net/weixin_45871756/article/details/139838646

版权

项目简介：

身份简介

学生：申请机房

教师：审核学生的预约申请

管理员：给学生、老师创建账号

机房简介

一共三个机房

1号机房 —最大容量20人

2号机房 —最大容量50人

3号机房 —最大容量100人

申请简介

申请订单每周由管理员负责清空

学生可以预约未来一周机房，时间周一到周五，时段分为上午和下午

教师审核预约，依据实际情况通过或者不通过

系统具体需求

（1）首先进入登录界面，可选择身份如下四个：

学生代表、老师、管理员、退出

（2）每个身份通过验证，进入菜单

学生需要输入：学号、姓名、登录密码

老师需要输入：职工号、姓名、登陆密码

管理员需要输入：管理员姓名、登陆密码

（3）学生具体功能

申请预约—预约机房

查看自己的预约----查看预约状态

查看所有预约—查看全部预约信息以及预约状态

取消预约—取消自身的预约，预约成功或者审核中的预约均可取消

注销登录—退出登录

（4）教师具体功能

查看所有预约—查看全部预约信息以及预约状态

审核预约—对学生的预约进行审核

注销登录—退出登录

（5）管理员具体功能

添加账号—添加学生或教师的账号，需要检测学生编号或教师职工号是否重复

查看账号—可以选择查看学生或教师的全部信息

查看机房—查看所有机房的信息

清空预约—清空所有预约记录

注销登录—退出登录

其中，预约状态分为审核中、预约成功、预约失败、取消预约

机房信息分为机房编号和最大容量

1. 先添加登录界面
2. 添加选择select（基类）
3. 添加student、teacher、manager（三个派生类）的cpp和h文件，h声明，cpp实现
4. 添加全局文件--登陆函数封装--学生登录实现--教师登录实现--管理员登录实现
5. 管理员模块先实现--登录注销--添加账号--显示账号--查看机房--清空预约
6. 学生模块--登陆注销--申请预约--显示预约--取消预约

// 学生：学号 姓名 密码
1 张三 123
2 李四 123456

// 教师：教师职工编号 姓名 密码
1 老王 123

/* 容器嵌套容器map
data: 1 interval: 2 stuId: 1 stuName: 张三 roomId: 3 status: 1
data: 2 interval: 1 stuId: 1 stuName: 张三 roomId: 2 status: 1

map<string, string> key代表 属性  value代表 实值
key  data       value  1
key  interval   value  2
key  stuId      value  1
key  stuName    value  张三
key  roomId     value  3 
key  status     value  1

map<int, map<string, string>>  key 预约记录条数  value 代表第一条记录中所有信息

*/

// ComputerRoom.h
// 这个文件用作管理机房被占用数量
#pragma once
#include<iostream>
using namespace std;


class ComputerRoom
{
public:

	int m_ComId;  // 机房id号
	int m_MaxNum; // 机房最大容量
};

// globalFile.h
#pragma once

// 管理员文件(首先会有一个初始的管理员账号密码)
#define ADMIN_FILE "admin.txt"
// 学生文件
#define STUDENT_FILE "student.txt"
// 教师文件
#define TEACHER_FILE "teacher.txt"
// 机房信息文件
#define COMPUTER_FILE "computerRoom.txt"
// 订单文件
#define ORDER_FILE "order.txt"

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

// 身份抽象基类
class Identity
{
public:

	// 操作菜单，纯虚函数，子类重写父类函数
	virtual void operMenu() = 0; // 每选择一个身份，会进入一个欢迎界面

	// 共性
	// 老师 学生 管理员 都有用户名和密码可以用一个父类的共性变量表四
	// 用户名
	string m_Name;
	// 密码
	string m_Pwd;
};

// manager.h
#pragma once
#include<iostream>
#include<string>
#include<fstream>
#include<vector>
#include<algorithm>   // for_each 算法
#include"Identity.h"
#include"teacher.h"
#include"student.h"
#include"computerRoom.h"
using namespace std;

// 管理员类
class Manager : public Identity
{
public:
	// 默认构造
	Manager();
	// 有参构造（管理员姓名，密码）
	Manager(string name, string pwd);

	// 选择菜单
	virtual void operMenu();

	// 添加账号
	void addPerson();
	// 查看账号
	void showPerson();
	// 查看机房信息
	void showComputer();
	// 清空预约记录
	void cleanFile();

	// 初始化容器
	void initVector();

	// 检测重复
	bool checkRepeat(int id, int type);

	// 学生容器
	vector<Student> vStu;
	// 教师容器
	vector<Teacher> vTea;

	// 机房信息容器
	vector<ComputerRoom> vCom;
};

// OrderFile.h
#pragma once
#include<iostream>
using namespace std;
#include<map>
#include<fstream>
#include"globalFile.h"
/*
data: 1 interval: 2 stuId: 1 stuName: 张三 roomId: 3 status: 1
data: 2 interval: 1 stuId: 1 stuName: 张三 roomId: 2 status: 1

map<string, string> key代表 属性  value代表 实值
key  data       value  1
key  interval   value  2
key  stuId      value  1
key  stuName    value  张三
key  roomId     value  3 
key  status     value  1

map<int, map<string, string>>  key 预约记录条数  value 代表第一条记录中所有信息

*/

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

	// 更新预约记录
	void updateOrder();

	// 记录预约条数
	int m_Size;

	// 记录所有预约信息的容器 key记录条数 value具体记录键值对信息
	map<int, map<string, string>> m_orderData;
};

// student.h
#pragma once
#include<iostream>
#include<fstream>
#include<string>
#include<vector>
#include"Identity.h"
#include"computerRoom.h"
#include"globalFile.h"
using namespace std;

#include"orderFile.h"

// 学生类的实现
class Student : public Identity
{
public:
	// 默认构造
	Student();
	// 有参构造 参数：学号、姓名、密码
	Student(int id, string name, string pwd);

	// 菜单界面
	virtual void operMenu();

	// 申请预约
	void applyOrder();

	// 查看自己预约
	void showMyOrder();

	// 查看所有预约
	void showAllOrder();

	// 取消预约
	void cancelOrder();

	// 学生学号
	int m_Id;

	// 机房容器
	vector<ComputerRoom> vCom;
};

// teacher.h
#pragma once
#include<iostream>
#include<string>
#include<vector>
#include"Identity.h"
#include"orderFile.h"
using namespace std;

// 教师类设计
class Teacher : public Identity
{
public:

	// 默认构造
	Teacher();
	// 有参构造(职工编号，姓名，密码)
	Teacher(int empId, string name, string pwd);

	// 菜单界面
	virtual void operMenu();
	// 查看所有预约
	void showAllOrder();
	// 审核预约
	void validOrder();

	// 职工号
	int m_EmpId; // 教师编号
};

// computer_order.cpp
#include "iostream"
#include "Identity.h"
#include <fstream>
#include <string>
#include "globalFile.h"
#include "student.h"
#include "teacher.h"
#include "manager.h"
using namespace std;

// 进入教师子菜单界面
void teacherMenu(Identity*& teacher)
{
	while (true)
	{
		// 调用教师子菜单
		teacher->operMenu();
		// 建立一个tearcher类的指针
		Teacher* tea = (Teacher*)teacher;

		int select = 0; // 接收用户的选择
		cin >> select;

		if (select == 1)
		{
			// 查看所有
			tea->showAllOrder();
		}
		else if (select == 2)
		{
			// 审核预约
			tea->validOrder();
		}
		else
		{
			// 注销预约
			delete teacher;
			cout << "注销成功" << endl;
			system("pause");
			system("cls");
			return;
		}
	}
}

// 进入学生子菜单界面
void studentMenu(Identity*& student)
{
	while (true)
	{
		// 调用学生子菜单
		student->operMenu();

		Student* stu = (Student*)student;

		int select = 0;
		cin >> select;

		if (select == 1)
		{
			// 添加账号
			//cout<<"申请预约" << endl;   // 这些为测试代码，测试if语句是否起作用
			stu->applyOrder();
		}
		else if (select == 2)
		{
			// 查看账号
			//cout << "查看自身预约" << endl;
			stu->showMyOrder();
		}
		else if (select == 3)
		{
			// 查看机房
			//cout << "查看所有人预约" << endl;
			stu->showAllOrder();	
		}
		else if (select == 4)
		{
			// 清空预约
			//cout << "取消预约" << endl;
			stu->cancelOrder();
		}
		else {
			cout << "注销成功！" << endl;

			delete student; // 销毁堆区对象

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

// 进入管理员子菜单界面
void managerMenu(Identity * &manager)
{
	while (true)
	{
		// 调用管理员的子菜单
		manager->operMenu(); // 多态 父类指针调用公共部分

		// 将父类指针转为子类指针，调用子类里其他接口
		Manager* man = (Manager*)manager;

		int select = 0;
		// 接收用户的选择
		cin >> select;

		if (select == 1)
		{
			// 添加账号
			//cout<<"添加账号" << endl;
			man->addPerson();
		}
		else if (select == 2)
		{
			// 查看账号
			//cout << "查看账号" << endl;
			man->showPerson();
		}
		else if (select == 3)
		{
			// 查看机房
			//cout << "查看机房" << endl;
			man->showComputer();
		}
		else if (select == 4)
		{
			// 清空预约
			//cout << "清空预约" << endl;
			man->cleanFile();
		}
		else {
			cout << "注销成功！" << endl;

			delete manager; // 销毁堆区对象

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

	}
}

// 登录功能 (参数1：操作文件名，参数2：操作身份类型)
void LoginIn(string fileName, int type)
{
	// 父类指针，用于指向子类对象
	Identity* person = NULL;  // 接收后面的student teacher manager

	// 读文件
	ifstream ifs;
	ifs.open(fileName, ios::in); // in 读文件

	// 判断文件是否存在
	if (!ifs.is_open())
	{
		cout<<"文件不存在" << endl;
		ifs.close();
		return;
	}

	// 准备接收用户的信息
	int id = 0;
	string name;
	string pwd;

	// 判断身份
	if (type == 1) // 学生身份
	{
		cout << "请输入你的学号：" << endl;
		cin >> id;
	}
	else if (type == 2)
	{
		cout << "请输入你的职工号：" << endl;
		cin >> id;
	}

	cout << "请输入用户名：" << endl;
	cin >> name;

	cout << "请输入密码：" << endl;
	cin >> pwd;

	if (type == 1)
	{
		// 学生身份验证
		int fId;  // txt 文件内部数据    id，name，pwd是用户输入
		string fName;
		string fPwd;
		while (ifs >> fId && ifs >> fName && ifs >> fPwd ) 
		{
			if (id == fId && name == fName && pwd == fPwd)
			{
				cout << "学生验证登录成功！" << endl;
				system("pause");
				system("cls");
				person = new Student(id, name, pwd);
				// 进入学生身份的子菜单
				studentMenu(person);

				return;
			}
		}
	}
	else if (type == 2)
	{
		// 教师身份验证
		int fId;  // txt 文件内部数据    id，name，pwd是用户输入
		string fName;
		string fPwd;
		while (ifs >> fId && ifs >> fName && ifs >> fPwd)
		{
			if (id == fId && name == fName && pwd == fPwd)
			{
				cout << "教师验证登录成功！" << endl;
				system("pause");
				system("cls");
				person = new Teacher(id, name, pwd);
				// 进入教师身份的子菜单
				teacherMenu(person);

				return;
			}
		}
	}
	else if (type == 3)
	{
		// 管理员身份验证
		string fName; // txt文件姓名
		string fPwd;  // txt文件密码
		while (ifs >> fName && ifs >> fPwd)
		{
			if (name == fName && pwd == fPwd)
			{
				cout << "管理员验证登录成功！" << endl;
				system("pause");
				system("cls");

				person = new Manager(name, pwd);

				// 进入管理员身份的子菜单
				managerMenu(person);

				return;
			}
		}
	}

	cout << "验证登录失败！" << endl;
	system("pause");
	system("cls");
	return;
}

int main()
{
	int select = 0; // 用于接收用户的选择
	
	while (true)
	{
		cout << "=================  欢迎来到传智播客机房预约系统  =================" << endl;
		cout << endl << "请输入您的身份:" << endl;
		cout << "\t\t------------------------------------\n";
		cout << "\t\t|                                  |\n";
		cout << "\t\t|            1.学生代表            |\n";
		cout << "\t\t|                                  |\n";
		cout << "\t\t|            2.老    师            |\n";
		cout << "\t\t|                                  |\n";
		cout << "\t\t|            3.管 理 员            |\n";
		cout << "\t\t|                                  |\n";
		cout << "\t\t|            0.退    出            |\n";
		cout << "\t\t|                                  |\n";
		cout << "\t\t------------------------------------\n";
		cout << "请输入您的选择：";

		cin >> select; // 接收用户选择

		switch (select) // 根据用户选择 实现不同接口
		{
		case 1: // 学生身份
			LoginIn(STUDENT_FILE, 1);
			break;
		case 2: // 老师身份
			LoginIn(TEACHER_FILE, 2);
			break;
		case 3: // 管理员身份
			LoginIn(ADMIN_FILE, 3);
			break;
		case 0: // 退出系统
			cout << "欢迎下一次使用"<<endl;
			system("pause");
			return 0;
			break;
		default:
			cout << "输入有误，请重新选择！" << endl;
			system("pause");
			system("cls"); // 清屏
			break;
		}
	}

	system("pause"); // 按任意键退出
	return 0;
}

// manager.cpp
#include "manager.h"
#include "globalFile.h"

// 默认构造
Manager::Manager()
{}
// 有参构造（管理员姓名，密码）
Manager::Manager(string name, string pwd)
{
	// 初始化管理员信息
	this->m_Name = name;
	this->m_Pwd = pwd;

	// 初始化容器 获取到所有文件中 学生、老师信息
	this->initVector();

	// 初始化机房信息
	ifstream ifs;
	ifs.open(COMPUTER_FILE, ios::in);

	ComputerRoom com;  // 机房编号和容量
	while (ifs >> com.m_ComId && ifs >> com.m_MaxNum)
	{
		vCom.push_back(com);
	}
	ifs.close();

	cout << "机房的数量为：" << vCom.size() << endl;
}

// 选择菜单
void Manager::operMenu()
{
	cout << "欢迎管理员：" <<this->m_Name<<"登录"<< endl;
	cout << "\t\t------------------------------------\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            1.添加账号             |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            2.查看账号            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            3.查看机房            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            4.清空预约            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            0.注销登录            |\n";
	cout << "\t\t------------------------------------\n";
	cout << "请输入您的选择：" << endl;
}

// 添加账号
void Manager::addPerson()
{
	cout << "请输入添加账号的类型：" << endl;
	cout << "1、添加学生" << endl;
	cout << "2、添加老师" << endl;

	string fileName; // 操作的文件名
	string tip;      // 提示ID （学号或者职工号通过选择用一个变量表示）

	string errorTip; // 重复错误提示

	ofstream ofs;    // 文件操作的对象

	int select = 0;
	cin >> select;

    // 控制选择的变量到底时哪个操作对象
	if (select == 1)
	{
		// 添加的是学生
		fileName = STUDENT_FILE;
		tip = "请输入学号：";
		errorTip = "学号重复，请重新输入";
	}
	else if (select == 2)
	{
		// 添加的是学生
		fileName = TEACHER_FILE;
		tip = "请输入职工号：";
		errorTip = "职工号重复，请重新输入";
	}
	else
	{
		cout << "输入错误，请重新输入" << endl;

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

	// 利用追加的方式写数据
	ofs.open(fileName, ios::out | ios::app);

	int id;     // 学号或者职工号
	string name;// 姓名
	string pwd; // 密码

	cout << tip << endl;

	while (true)
	{
		cin >> id;
		bool ret = checkRepeat(id, select); // 通过id来判断一个类型的是否重复
		if (ret) // 有重复
		{
			cout << errorTip << endl;
		}
		else
		{
			break;
		}
	}

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

	cout << "请输入密码：" << endl;
	cin >> pwd;

	// 向文件中添加数据
	ofs << id << " " << name << " " << pwd << " " << endl;
	cout << "添加成功" << endl;

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

	ofs.close();

	// 调用初始化容器接口，重新获取文件中数据 防止刚加入学号的重复添加
	this->initVector();

}

void printStudent(Student& s)
{
	cout << "学号：" << s.m_Id <<" " << "姓名：" << s.m_Name << " " << "密码：" << s.m_Pwd << endl;
}

void printTeacher(Teacher& t)
{
	cout << "职工号：" << t.m_EmpId << " " << "姓名：" << t.m_Name << " " << "密码：" << t.m_Pwd << endl;
}

// 查看账号
void Manager::showPerson()
{
	cout << "请选择查看的内容：" << endl;
	cout << "1、查看所有的学生" << endl;
	cout << "2、查看所有老师" << endl;

	int select = 0;
	cin >> select;

	if (select == 1)
	{
		// 查看学生
		cout << "所有学生信息如下：" << endl;
		for_each(vStu.begin(), vStu.end(), printStudent);
	}
	else if (select == 2)
	{
		// 查看教师
		cout << "所有教师信息如下：" << endl;
		for_each(vTea.begin(), vTea.end(), printTeacher);
	}
	else
	{
		cout << "输入错误请重新输入" << endl;
		system("pause");
		system("cls");
	}

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

void printComputerRoom(ComputerRoom& c)
{
	cout << "机房编号：" << c.m_ComId << " " << "机房的最大容量：" << c.m_MaxNum << endl;
}

// 查看机房信息
void Manager::showComputer()
{
	cout << "机房的信息如下：" << endl;
	for_each(vCom.begin(), vCom.end(), printComputerRoom);
	/*
	for(vector<ComputerRoom>::iterator it = vCom.begin(); it != vCom.end(); it++)
	{
	    cout << "机房编号：" << it->m_ComId << " " << "机房的最大容量：" << it->m_MaxNum << endl;
	}
	*/

	system("pause");
	system("cls");
}
// 清空预约记录
void Manager::cleanFile()
{
	ofstream ofs(ORDER_FILE, ios::trunc);
	ofs.close();

	/*
	  ios::in：以读模式打开文件（ifstream 默认模式）。
      ios::out：以写模式打开文件（ofstream 默认模式）。
      ios::app：以追加模式打开文件，写入的数据会被追加到文件末尾。
      ios::trunc：如果文件存在，打开时清空文件内容。
      ios::binary：以二进制模式打开文件，而不是文本模式。
	*/
	cout << "清空成功！" << endl;
	system("pause");
	system("cls");
}

// 初始化容器
void Manager::initVector()
{
	// 确保容器清空状态
	vStu.clear();
	vTea.clear();

	// 读取信息 老师
	ifstream ifs;
	ifs.open(STUDENT_FILE, ios::in);
	if (!ifs.is_open())
	{
		cout << "文件读取失败" << endl;
		return;
	}

	Student s;
	while (ifs >> s.m_Id && ifs >> s.m_Name && ifs >> s.m_Pwd)
	{
		vStu.push_back(s);
	}

	cout << "当前学生数量为：" << vStu.size() << endl;
	ifs.close();

	// 读取信息 老师
	ifs.open(TEACHER_FILE, ios::in);

	Teacher t;
	while (ifs >> t.m_EmpId && ifs >> t.m_Name && ifs >> t.m_Pwd)
	{
		vTea.push_back(t);
	}

	cout << "当前老师数量为：" << vTea.size() << endl;
	ifs.close();

}

// 检测重复 参数1 检测学号/职工号 参数2 检测类型
bool Manager::checkRepeat(int id, int type)
{
	if (type == 1)
	{
		// 检测学生
		for (vector<Student>::iterator it = vStu.begin(); it != vStu.end();it++)
		{   //声明一个迭代器it，类型是vector<Student>::iterator
			if (id == it->m_Id)
			{
				return true;
			}
		}

	}
	else if (type == 2)
	{
		// 检测老师
		for (vector<Teacher>::iterator it = vTea.begin(); it != vTea.end();it++)
		{
			if (id == it->m_EmpId)
			{
				return true;
			}
		}
	}
	else
	{
		cout << "输入错误，请重新输入" << endl;

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

	return false;
}

// orderFile.cpp
#include"orderFile.h"


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

	string date;       // 日期
	string interval;   // 时间段
	string stuId;      // 学生编号
	string stuName;    // 学生姓名
	string roomId;     // 机房编号
	string status;     // 预约状态

	this->m_Size = 0;  // 预约记录条数

	while (ifs >> date && ifs >> interval && ifs >> stuId && ifs 
		>> stuName && ifs >> roomId && ifs >> status)
	{
		/*
		在ifs输入时遇见空格自动换行
		cout << date << endl;
		cout << interval << endl;
		cout << stuId << endl;
		cout << stuName << endl;
		cout << roomId << endl;
		cout << status << endl;
		cout << endl;
		*/

		// date:1111
		string key;
		string value;
		map<string, string>m;

        // 这里通过find : 来分离键值对，达到有效输出的效果，并且将分离后的结果存入map容器m中
		int pos = date.find(":");  // 返回4
		if (pos != -1)
		{
			key = date.substr(0, pos);
			value = date.substr(pos + 1, date.size() - pos - 1); // size = 9 pos = 4 size - pos - 1 = 5 - 1 = 4
			m.insert(make_pair(key,value));
		}

		//cout << "key = " << key << endl;
		//cout << "value = " << value << endl;

		// 截取时间段interval
		pos = interval.find(":");
		if (pos != -1)
		{
			key = interval.substr(0, pos);
			value = interval.substr(pos + 1, interval.size() - pos - 1); 
			m.insert(make_pair(key, value));
		}
		// 截取学号stuId
		pos = stuId.find(":");
		if (pos != -1)
		{
			key = stuId.substr(0, pos);
			value = stuId.substr(pos + 1, stuId.size() - pos - 1);
			m.insert(make_pair(key, value));
		}
		// 截取姓名stuName
		pos = stuName.find(":");
		if (pos != -1)
		{
			key = stuName.substr(0, pos);
			value = stuName.substr(pos + 1, stuName.size() - pos - 1);
			m.insert(make_pair(key, value));
		}
		// 截取机房号roomId
		pos = roomId.find(":");
		if (pos != -1)
		{
			key = roomId.substr(0, pos);
			value = roomId.substr(pos + 1, roomId.size() - pos - 1);
			m.insert(make_pair(key, value));
		}
		// 截取预约状态status
		pos = status.find(":");
		if (pos != -1)
		{
			key = status.substr(0, pos);
			value = status.substr(pos + 1, status.size() - pos - 1);
			m.insert(make_pair(key, value));
		}

		// 将小map容器放入到大的map容器
		this->m_orderData.insert(make_pair(this->m_Size, m));
		this->m_Size++;

	}

	ifs.close();

	// 测试最大的map容器
	/*
	for (map<int, map<string, string>>::iterator it = m_orderData.begin(); it != m_orderData.end(); it++)
	{
		cout << "条数为 = " << it->first << " value = " << endl;
		for (map<string, string>::iterator mit = (*it).second.begin(); mit != it->second.end();mit++)
		{
			cout << " key = " << mit->first << " value = " << mit->second << " ";
		}
		cout << endl;
	}
	*/
}


// 更新预约记录
void OrderFile::updateOrder()
{
	if (this->m_Size == 0)
	{
		return;  // 预约记录0，直接return
	}

	ofstream ofs;
	ofs.open(ORDER_FILE, ios::out | ios::trunc);
	for (int i = 0; i < this->m_Size; i++)
	{
		ofs << "date:" << this->m_orderData[i]["date"] << " ";
		ofs << "interval:" << this->m_orderData[i]["interval"] << " ";
		ofs << "stuId:" << this->m_orderData[i]["stuId"] << " ";
		ofs << "stuName:" << this->m_orderData[i]["stuName"] << " ";
		ofs << "roomId:" << this->m_orderData[i]["roomId"] << " ";
		ofs << "status:" << this->m_orderData[i]["status"] << endl;

	}

	ofs.close();
}

// student.cpp
#include "student.h"
using namespace std;

// 默认构造
Student::Student()
{}
// 有参构造 参数：学号、姓名、密码
Student::Student(int id, string name, string pwd)
{
	// 初始化属性
	this->m_Id = id;
	this->m_Name = name;
	this->m_Pwd = pwd;

	// 初始化机房信息
	ifstream ifs;
	ifs.open(COMPUTER_FILE, ios::in);

	ComputerRoom com;

	while (ifs >> com.m_ComId && ifs >> com.m_MaxNum)
	{
		// 将读取的信息放入vCom容器中
		vCom.push_back(com);
	}
}

// 菜单界面
void Student::operMenu()
{
	cout << "欢迎学生代表：" << this->m_Name << "登录" << endl;
	cout << "\t\t------------------------------------\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            1.申请预约            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            2.查看我的预约        |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            3.查看所有预约        |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            4.取消预约            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            0.注销登录            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t------------------------------------\n";
	cout << "请输入您的选择：" << endl;

}
// 申请预约
void Student::applyOrder()
{
	cout << "机房开始时间为周一至周五！" << endl;
	cout << "请输入申请预约的时间：" << endl;
	cout << "1、周一" << endl;
	cout << "2、周二" << endl;
	cout << "3、周三" << endl;
	cout << "4、周四" << endl;
	cout << "5、周五" << endl;

	int date = 0;     // 日期
	int interval = 0; // 间隔段，上午/下午
	int room = 0;     // 机房编号

	while (true)
	{
		cin >> date;
		if (date >= 1 && date <= 5) {
			break;
		}
		cout << "日期输入有误，请重新输入！" << endl;
	}

	cout << "请输入申请预约的时间段：" << endl;
	cout << "1、上午" << endl;
	cout << "2、下午" << endl;
	while (true)
	{
		cin >> interval;
		if (interval >= 1 && interval <= 2) {
			break;
		}
		cout << "时间段输入有误，请重新输入！" << endl;
	}

	cout << "请选择机房：" << endl;
	for (int i = 0; i < vCom.size(); i++)
	{
		cout << vCom[i].m_ComId << "号机房容量为：" << vCom[i].m_MaxNum << endl;
	}

	while (true)
	{
		cin >> room;
		if (room >= 1 && room <= 3) {
			break;
		}
		cout << "机房输入有误，请重新输入！" << endl;
	}

	cout << "预约成功！审核中" << endl;

	ofstream ofs;
	ofs.open(ORDER_FILE, ios::app);

	ofs << "date:" << date << " ";
	ofs << "interval:" << interval << " ";
	ofs << "stuId:" << this->m_Id << " ";
	ofs << "stuName:" << this->m_Name << " ";
	ofs << "roomId:" << room << " ";
	ofs << "status:" << 1 << endl;  // 1 表示审核中

	ofs.close();
	system("pause");
	system("cls");
}
// 查看自己预约
void Student::showMyOrder()
{
	OrderFile of;  // 创建OrderFile类型对象，就会调用构造函数
	if (of.m_Size == 0) {
		cout << "无预约记录" << endl;
		system("pause");
		system("cls");
		return;
	}

	for (int i = 0; i < of.m_Size; i++)
	{
		// 找到自身预约
		// string 转 int  1、利用.c_str()转为const char *  2、利用atoi (const char *) 转int
		if (this->m_Id == atoi(of.m_orderData[i]["stuId"].c_str()))  // c_str() 转为c语言字符串 atoi 字符串转int
		{
			cout << "预约日期:周" << of.m_orderData[i]["date"];
			cout << " 时间段:" << (of.m_orderData[i]["interval"] == "1" ? "上午" : "下午");
			cout << " 机房号:" << of.m_orderData[i]["roomId"];
			string status = " 状态:";
			// 1 审核中 2 已预约 -1 预约失败 0 取消预约
			if (of.m_orderData[i]["status"] == "1") {
				status += "审核中";
			}
			else if (of.m_orderData[i]["status"] == "2") {
				status += "预约成功";
			}
			else if (of.m_orderData[i]["status"] == "-1") {
				status += "预约失败，审核未通过";
			}
			else  
			{
				status += "预约已取消";
			}
			cout << status << endl;

		}
	}
	system("pause");
	system("cls");
}
// 查看所有预约
void Student::showAllOrder()
{
	OrderFile of;
	if (of.m_Size == 0) {
		cout << "无预约记录" << endl;
		system("pause");
		system("cls");
		return;
	}

	for (int i = 0; i < of.m_Size; i++)
	{
		cout << i + 1 << "、";
		cout << "预约日期：周" << of.m_orderData[i]["date"];
		cout << " 时间段:" << (of.m_orderData[i]["interval"] == "1" ? "上午" : "下午");
		cout << " 学号:" << of.m_orderData[i]["stuId"];
		cout << " 姓名:" << of.m_orderData[i]["stuName"];
		cout << " 机房号:" << of.m_orderData[i]["roomId"];
		string status = " 状态:";
		// 1 审核中 2 已预约 -1 预约失败 0 取消预约
		if (of.m_orderData[i]["status"] == "1") {
			status += "审核中";
		}
		else if (of.m_orderData[i]["status"] == "2") {
			status += "预约成功";
		}
		else if (of.m_orderData[i]["status"] == "-1") {
			status += "预约失败，审核未通过";
		}
		else
		{
			status += "预约已取消";
		}
		cout << status << endl;
	}

	system("pause");
	system("cls");
}
// 取消预约
void Student::cancelOrder()
{
	OrderFile of;
	if (of.m_Size == 0) {
		cout << "无预约记录" << endl;

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

	cout << "审核中或者预约成功的记录可以取消，请输入取消的记录" << endl;

	int index = 1;
	vector<int> v; // 存放在最大容器的下标编号
	for (int i = 0; i < of.m_Size; i++)
	{
		// 先判断自身学号
		if (atoi(of.m_orderData[i]["stuId"].c_str()) == this->m_Id)
		{
			// 再筛选状态 审核成功或预约成功
			if (of.m_orderData[i]["status"] == "1" || of.m_orderData[i]["status"] == "2")
			{
				v.push_back(i);
				cout << index++ << "、";
				cout << "预约日期：周" << of.m_orderData[i]["date"];
				cout << " 时间段：" << (of.m_orderData[i]["interval"] == "1" ? "上午" : "下午");
				cout << " 机房编号：" << of.m_orderData[i]["roomId"];
				string status = " 状态:";
				if (of.m_orderData[i]["status"] == "1") {
					status += "审核中";
				}
				else if (of.m_orderData[i]["status"] == "2") {
					status += "预约成功";
				}

				cout << status << endl;

			}
		}
	}

	cout << "请输入取消的记录，0代表返回" << endl;
	int select = 0;

	while (true)
	{
		cin >> select;

		if (select >= 0 && select <= v.size())
		{
			if (select == 0) {
				break;
			}
			else {
				of.m_orderData[v[select - 1]]["status"] = "0";
				of.updateOrder();

				cout << "已取消预约" << endl;
				break;
			}
		}
		cout << "输入有误，请重新输入！" << endl;
	}

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

// teacher.cpp
#include "teacher.h"
using namespace std;

// 默认构造
Teacher::Teacher()
{}
// 有参构造(职工编号，姓名，密码)
Teacher::Teacher(int empId, string name, string pwd)
{
	// 初始化属性
	this->m_EmpId = empId;
	this->m_Name = name;
	this->m_Pwd = pwd;
}

// 菜单界面
void Teacher::operMenu() 
{
	cout << "欢迎教师：" << this->m_Name << "登录" << endl;
	cout << "\t\t------------------------------------\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            1.查看所有预约        |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            2.审核预约            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t|            0.注销登录            |\n";
	cout << "\t\t|                                  |\n";
	cout << "\t\t------------------------------------\n";
	cout << "请输入您的选择：" << endl;
}
// 查看所有预约
void Teacher::showAllOrder()
{
	OrderFile of;
	if (of.m_Size == 0) {
		cout << "无预约记录" << endl;
		system("pause");
		system("cls");
		return;
	}

	for (int i = 0; i < of.m_Size; i++)
	{
		cout << i + 1 << "、";
		cout << "预约日期：周" << of.m_orderData[i]["date"];
		cout << " 时间段:" << (of.m_orderData[i]["interval"] == "1" ? "上午" : "下午");
		cout << " 学号:" << of.m_orderData[i]["stuId"];
		cout << " 姓名:" << of.m_orderData[i]["stuName"];
		cout << " 机房号:" << of.m_orderData[i]["roomId"];
		string status = " 状态:";
		// 1 审核中 2 已预约 -1 预约失败 0 取消预约
		if (of.m_orderData[i]["status"] == "1") {
			status += "审核中";
		}
		else if (of.m_orderData[i]["status"] == "2") {
			status += "预约成功";
		}
		else if (of.m_orderData[i]["status"] == "-1") {
			status += "预约失败，审核未通过";
		}
		else
		{
			status += "预约已取消";
		}
		cout << status << endl;
	}

	system("pause");
	system("cls");
}
// 审核预约
void Teacher::validOrder()
{
	OrderFile of;
	if (of.m_Size == 0) {
		cout << "无预约记录" << endl;
		system("pause");
		system("cls");
		return;
	}

	vector<int> v;
	int index = 0;
	cout << "待审核的预约记录如下：" << endl;
	for (int i = 0; i < of.m_Size; i++)
	{
		if (of.m_orderData[i]["status"] == "1")
		{
			v.push_back(i);
			cout << ++index << "、";
			cout << "预约日期：周" << of.m_orderData[i]["date"];
			cout << " 时间段：" << (of.m_orderData[i]["interval"] == "1" ? "上午" : "下午");
			cout << " 学生编号：" << of.m_orderData[i]["stuId"];
			cout << " 学生姓名：" << of.m_orderData[i]["stuName"];
			cout << " 机房号：" << of.m_orderData[i]["roomId"];
			string status = "状态：审核中";
			cout << status << endl;

		}
	}

	cout << "请输入审核的预约记录，0表示返回" << endl;
	int select = 0;  // 接收用户选择的预约记录
	int ret = 0;     // 接收预约的结果记录
	while (true)
	{
		cin >> select;
		if (select >= 0 && select <= v.size())
		{
			if (select == 0) {
				break;
			}
			else
			{
				cout << "请输入审核结果" << endl;
				cout << "1、通过" << endl;
				cout << "2、不通过" << endl;
				cin >> ret;
				if (ret == 1) {
					// 通过
					of.m_orderData[v[select - 1]]["status"] = "2";
				}
				else
				{
					// 不通过
					of.m_orderData[v[select - 1]]["status"] = "-1";
				}
				of.updateOrder();
				cout << "审核完毕！" << endl;
				break;
			}
		}
		cout << "输入有误，请重新输入" << endl;
	}

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