cpp综合项目—机房预约系统

1、机房预约系统需求

1.1、身份简介

1.2、机房简介

1.3、申请简介

1.4、系统具体需求

2、创建项目

3、创建主菜单

3.1 菜单实现

3.2、接口实现

4、退出功能实现

4.1、退出功能实现

4.2、测试退出

5、创建身份类

5.1、身份的基类

5.2、学生类

5.3、老师类

5.4、管理员类

6、登录模块

6.1、全局文件添加

6.2、登录函数封装

6.3、学生登录实现

6.4、教师登录实现

6.5、管理员登录实现

7、管理员模块

7.1、管理员登录和注销

7.2、添加账号

7.3、显示账号

7.4、查看机房

7.5、清空预约

8、学生模块

8.1、学生登录和注销

8.2、申请预约

8.3、显示预约

8.4、取消预约

9、教师模块

9.1、教师登录和注销

9.2、查看所有预约

9.3、审核预约

附源码：

1、资源目录结构

2、头文件

2.1、computerRoom.h

2.2、globalFile.h

2.3、Identity.h

2.4、Manager.h

2.5、OrderFile.h

2.6、Student.h

2.7、Teacher.h

3、源文件

3.1、main.cpp

3.2、Manager.cpp

3.3、OrderFile.cpp

3.4、Student.cpp

3.5、Teacher.cpp

1、机房预约系统需求

1.1、身份简介

分别有三种身份使用该程序

学生代表：申请使用机房
教师：审核学生的预约申请
管理员：给学生、教师创建账号

1.2、机房简介

机房总共有3间

1号机房 --- 最大容量20人
2号机房 --- 最多容量50人
3号机房 --- 最多容量100人

1.3、申请简介

申请的订单每周由管理员负责清空。
学生可以预约未来一周内的机房使用，预约的日期为周一至周五，预约时需要选择预约时段（上午、下午）
教师来审核预约，依据实际情况审核预约通过或者不通过

1.4、系统具体需求

首先进入登录界面，可选登录身份有：

学生代表
老师
管理员
退出

每个身份都需要进行验证后，进入子菜单

学生需要输入：学号、姓名、登录密码
老师需要输入：职工号、姓名、登录密码
管理员需要输入：管理员姓名、登录密码

学生具体功能

申请预约 --- 预约机房
查看自身的预约 --- 查看自己的预约状态
查看所有预约 --- 查看全部预约信息以及预约状态
取消预约 --- 取消自身的预约，预约成功或审核中的预约均可取消
注销登录 --- 退出登录

教师具体功能

查看所有预约 --- 查看全部预约信息以及预约状态
审核预约 --- 对学生的预约进行审核
注销登录 --- 退出登录

管理员具体功能

添加账号 --- 添加学生或教师的账号，需要检测学生编号或教师职工号是否重复
查看账号 --- 可以选择查看学生或教师的全部信息
查看机房 --- 查看所有机房的信息
清空预约 --- 清空所有预约记录
注销登录 --- 退出登录

2、创建项目

以vs2022为例

3、创建主菜单

功能描述：

设计主菜单，与用户进行交互

3.1 菜单实现

主函数main添加菜单提示，代码如下：

int main() {

	int select; //用于接受用户的输入

	while (true) {
        cout << "======================  欢迎来到qxer机房预约系统  ====================="
            << 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 << "输入您的选择: ";

	}

	system("pause");
	return 0;
}

效果图：

3.2、接口实现

在main中，继续添加代码：

int main() {

	int select; //用于接受用户的输入

	while (true) {
	//..........

        cin >> select;
        switch (select) {
        case 1:     //学生模块
            break;
        case 2:     //教师模块
            break;
        case 3:     //管理员模块
            break;
        case 4:     //退出
            break;
        default:
            cout << "输入有误，请重新输入！" << endl;
            system("pause");
            system("cls");
            break;
        }

	}

	system("pause");
	return 0;
}

效果图：

至此，页面搭建完成！

4、退出功能实现

4.1、退出功能实现

在main函数分支0选项中，添加退出程序

case 0:     //退出
    cout << "退出成功,欢迎下次使用~" << endl;
    return 0;
    break;

4.2、测试退出

运行程序

效果图：

退出功能完成！

5、创建身份类

5.1、身份的基类

在整个系统中，有三种身份，分别为：学生代表、老师以及管理员
三种身份有其共性也有其特性，因此我们可以将三种身份抽象出一个身份基类identity
在头文件下创建Identity.h文件

Identity.h中添加如下代码：

//身份基类
class Identity {
public:

	//纯虚函数，显示菜单
	virtual void operMeun() = 0;

	//用户名
	string m_Name;
	
	//密码
	string m_Pwd;

};

5.2、学生类

5.2.1 功能分析

学生类主要功能是可以通过类中成员函数，实现预约实验室操作
学生类中主要功能有：

显示学生操作的菜单界面
申请预约
查看自身预约
查看所有预约
取消预约

5.2.2 类的创建

在头文件以及源文件下创建 Student.h 和 Student.cpp文件

1、Student.h中添加如下代码：

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

#include"Identity.h"

class Student :public Identity {
public:
	//构造函数
	Student();
	Student(int id,string name,string pwd);

	//显示菜单
	void operMenu();	
	
	//申请预约
	void applyOrder();

	//查看我的预约
	void showMyOrder();

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

	//取消预约
	void cancelOrder();	

	//学号
	int m_Id;


};

2、Student.cpp中添加如下代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include"Student.h"

//构造函数
Student::Student() {

}
Student::Student(int id, string name, string pwd){

}

//显示菜单
void Student::operMenu() {

}

//申请预约
void Student::applyOrder() {

}

//查看我的预约
void Student::showMyOrder() {

}

//查看所有预约
void Student::showAllOrder() {

}

//取消预约
void Student::cancelOrder() {

}

5.3、老师类

5.3.1 功能分析

教师类主要功能是查看学生的预约，并进行审核
教师类中主要功能有：

显示教师操作的菜单界面
查看所有预约
审核预约

5.3.2 类的创建

在头文件以及源文件下创建 Teacher.h 和 Teacher.cpp文件

1、Teacher.h中添加如下代码：

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

#include"Identity.h"

class Teacher :public Identity {
public:
	//构造函数
	Teacher();
	Teacher(int Empid, string name, string pwd);

	//显示菜单
	void operMenu();

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

	//审核预约
	void validOrder();	

	//职工号
	int m_EmpId;


};

2、Teacher.cpp中添加如下代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include"Teacher.h"

//构造函数
Teacher::Teacher() {

}
Teacher::Teacher(int Empid, string name, string pwd) {

}

//显示菜单
void Teacher::operMenu() {

}

//查看所有预约
void Teacher::showAllOrder() {

}

//审核预约
void Teacher::validOrder() {

}

5.4、管理员类

5.4.1 功能分析

管理员类主要功能是对学生和老师账户进行管理，查看机房信息以及清空预约记录
管理员类中主要功能有：

显示管理员操作的菜单界面
添加账号
查看账号
查看机房信息
清空预约记录

5.4.2 类的创建

在头文件以及源文件下创建 Manager.h 和 Manager.cpp文件

1、Manager.h中添加如下代码：

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

#include"Identity.h"

class Manager :public Identity {
public:
	//构造函数
	Manager();
	Manager(string name, string pwd);

	//显示管理员操作的菜单界面
	void operMenu();

	//添加账号
	void addPerson();

	//查看账号
	void showPerson();

	//查看机房信息
	void showCompter();

	//清空预约记录
	void cleanFile();


};

2、Manager.cpp中添加如下代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include"Manager.h"

//构造函数
Manager::Manager() {

}
Manager::Manager(string name, string pwd) {

}

//显示管理员操作的菜单界面
void Manager::operMenu() {

}

//添加账号
void Manager::addPerson() {

}

//查看账号
void Manager::showPerson() {

}

//查看机房信息
void Manager::showCompter() {

}

//清空预约记录
void Manager::cleanFile() {

}

6、登录模块

6.1、全局文件添加

功能描述：

不同的身份可能会用到不同的文件操作，我们可以将所有的文件名定义到一个全局的文件中
在头文件中添加 globalFile.h 文件

1、添加如下代码：

#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"

2、同级目录创建文件

6.2、登录函数封装

功能描述：

根据用户的选择，进入不同的身份登录

在main.cpp文件中添加全局函数 void LoginIn(string fileName, int type)

参数：

fileName --- 操作的文件名
type --- 登录的身份（1代表学生、2代表老师、3代表管理员）

1、LoginIn中添加如下代码

#include"Identity.h"
#include<fstream>
#include"globalFile.h"

//全局登录验证函数
void loginIn(string fileName,int type) {

    //父类指针,用于实现多态
    Identity* person = NULL;

    ifstream ifs(fileName,ios::in);

    if (!ifs.is_open()) {
        cout << "文件不存在！" << endl;
        ifs.close();
        return;
    }

    int id;
    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) {
        //学生登录验证
    }
    else if (type == 2) {
        //教师登录验证
    }
    else if(type == 3){
        //管理员登录验证
    }
    else {
        cout << "验证登录失败！" << endl;
        system("pause");
        system("cls");
    }

}

2、在main函数中的switch分支分别调用登录接口

6.3、学生登录实现

在student.txt文件中添加两条学生信息，用于测试

添加信息:

1 张三 123

2 李四 456

其中：

第一列代表学号
第二列代表 学生姓名
第三列代表密码

效果图：

1、在Login函数的学生分支中加入如下代码，验证学生身份

if (type == 1) {
        //学生登录验证
        int fId;
        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);
                //进入学生类菜单


                return;
            }
        }
    }

3、效果图

6.4、教师登录实现

在teacher.txt文件中添加一条老师信息，用于测试

添加信息:

1 老王 123

其中：

第一列代表 教师职工编号
第二列代表 教师姓名
第三列代表密码

效果图：

在Login函数的教师分支中加入如下代码，验证教师身份

else if (type == 2) {
        //教师登录验证
        int fId;
        string fName;
        string fPwd;

        while (ifs>>fId&&ifs>>fName&&ifs>>fPwd) {
            if (id == fId && fName ==name && fPwd == pwd) {
                cout << "教师登录成功" << endl;
                system("pause");
                system("cls");
                person = new Teacher(id, name, pwd);
                //进入教师类菜单

                
                return;
            }          
        }
    }

测试：

6.5、管理员登录实现

在admin.txt文件中添加一条管理员信息，由于我们只有一条管理员，因此本案例中没有添加管理员的功能

添加信息:

admin 123

其中：

admin代表管理员用户名，

123代表管理员密码

效果图：

在Login函数的管理员分支中加入如下代码，验证管理员身份

else if(type == 3){
        //管理员登录验证
        string fName;
        string fPwd;
        while (ifs>>fName&&ifs>>fPwd) {
            if (name == fName && pwd == fPwd) {
                cout << "管理员验证登录成功！" << endl;
                system("pause");
                system("cls");
                person = new Manager(name,pwd);
                //进入管理员类菜单


                return;
            }
        }

    }

测试：

7、管理员模块

7.1、管理员登录和注销

7.1.1 构造函数

在Manager类的构造函数中，初始化管理员信息，代码如下：

//有参构造 
Manager::Manager(string name, string pwd) {     
    this->m_Name = name;     
    this->m_Pwd = pwd; 
}

7.1.2 管理员子菜单

在机房预约系统.cpp中，当用户登录的是管理员，添加管理员菜单接口
将不同的分支提供出来

添加账号
查看账号
查看机房
清空预约
注销登录

实现注销功能

在main.cpp 中添加全局函数 void managerMenu(Identity * &manager)，代码如下：

//管理员菜单
void managerMenu(Identity*& manager) {

    //父类指针强制转换为子类指针,以调用子类的成员
    Manager* man = (Manager*)manager;

    while (true) {

        man->operMenu();
        int select;
        cin >> select;

        switch (select) {
        case 1:     //添加账号
            man->addPerson();
            break;
        case 2:     //查看账号
            man->showPerson();
            break;
        case 3:     //查看机房
            man->showCompter();
            break;
        case 4:     //清空预约
            man->cleanFile();
            break;
        default:
            delete manager;
            cout << "注销成功" << endl;
            system("pause");
            system("cls");
            return;

        }
    }

}

7.1.3 菜单功能实现

在实现成员函数void Manager::operMenu() 代码如下：

//显示管理员操作的菜单界面
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 << "\t\t ---------------------------------\n";
    cout << "请选择您的操作： " << endl;

}

7.1.4 接口对接

管理员成功登录后，调用管理员子菜单界面
在管理员登录验证分支中，添加代码：

//进入管理员子菜单

managerMenu(person);

添加效果如下：

测试：

7.2、添加账号

功能描述：

给学生或教师添加新的账号

功能要求：

添加时学生学号不能重复、教师职工号不能重复

7.2.1 添加功能实现

在Manager的addPerson成员函数中，实现添加新账号功能，代码如下：

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

    string filename;
    string tip;

    int select;
    cin >> select;

    if (select == 1) {
        filename = STUDENT_FILE;
        tip = "请输入学号：";
    }
    else {
        filename = TEACHER_FILE;
        tip = "请输入职工号：";
    }

    ofstream ofs(filename,ios::out|ios::app);
    int id;
    string name;
    string pwd;

    cout << tip << endl;
    cin >> id;

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

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

    //写入文件
    ofs << id << " " << name << " " << pwd << " " << endl;
    cout << "添加成功！" << endl;

    system("pause");
    system("cls");
    ofs.close();
}

测试：

7.2.2 去重操作

功能描述：添加新账号时，如果是重复的学生编号，或是重复的教师职工编号，提示有误

7.2.2.1 读取信息

要去除重复的账号，首先要先将学生和教师的账号信息获取到程序中，方可检测
在manager.h中，添加两个容器，用于存放学生和教师的信息
添加一个新的成员函数 void initVector() 初始化容器

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

    //学生容器
    vector<Student> vStu;

    //教师容器
    vector<Teacher> vTea;

添加位置：

在Manager的成员函数initVector()中，获取目前的学生和教师信息

代码如下：

void Manager::initVector() {
    //确保读取前，容器为空
    vTea.clear();
    vStu.clear();

    ifstream ifs;

    //读取学生信息
    ifs.open(STUDENT_FILE,ios::in);
    if (!ifs.is_open()) {
        cout << "文件读取失败！";
        ifs.close();
    }

    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);
    if (!ifs.is_open()) {
        cout << "文件读取失败！"<<endl;
        ifs.close();
    }

    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();

}

在有参构造函数中，调用初始化容器函数

Manager::Manager(string name, string pwd) {
	this->m_Name = name;
	this->m_Pwd = pwd;
    this->initVector();
}

7.2.2.2 去重函数封装

在manager.h文件中添加成员函数 bool checkRepeat(int id, int type);

//检测重复 参数:(传入id，传入类型) 返回值：(true 代表有重复，false代表没有重复)     
bool checkRepeat(int id, int type);

在manager.cpp文件中实现成员函数 bool checkRepeat(int id, int type);

bool Manager::checkRepeat(int id, int type) {
    if (type == 1) {
        //检测学生
        for (int i = 0; i < vStu.size();i++) {
            if (vStu[i].m_Id == id) {
                return true;
            }
        }
    }
    else {
        //检测老师
        for (int i = 0; i < vTea.size(); i++) {
            if (vTea[i].m_EmpId == id) {
                return true;
            }
        }
    }

    return false;
}

在添加学生编号或者教师职工号时，新增代码检测是否有重复，代码如下：

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

    string filename;
    string tip;
    string errorTip;

    int select;
    cin >> select;

    if (select == 1) {
        filename = STUDENT_FILE;
        tip = "请输入学号：";
        errorTip = "学号重复，请重新输入：";
    }
    else {
        filename = TEACHER_FILE;
        tip = "请输入职工号：";
        errorTip = "职工号重复，请重新输入：";
    }

    ofstream ofs(filename,ios::out|ios::app);
    int id;
    string name;
    string pwd;

    while (true) {
        cout << tip << endl;
        cin >> id;
        bool ret = checkRepeat(id, select);
        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();
}

新增位置：

测试：

7.2.2.4 bug解决

bug描述：

虽然可以检测重复的账号，但是刚添加的账号由于没有更新到容器中，因此不会做检测
导致刚加入的账号的学生号或者职工编号，再次添加时依然可以重复

解决方案：

在每次addPerson（）中添加新账号时，重新初始化容器

在添加完毕后，加入代码：

//初始化容器
this->initVector();

再次测试，刚加入的账号不会重复添加了！

7.3、显示账号

7.3.1 显示功能实现

在Manager的showPerson成员函数中，实现显示账号功能，代码如下：

//查看账号
void Manager::showPerson() {
    cout << "请输入你想查看的用户类型：" << endl;
    cout << "1、查看学生的账号" << endl;
    cout << "2、查看老师的账号" << endl;

    int select;
    cin >> select;

    if (select == 1) {
        //查看学生
        for (int i = 0; i < vStu.size();i++) {
            cout << "学号：" << vStu[i].m_Id 
                << "  姓名：" << vStu[i].m_Name 
                << "  密码：" << vStu[i].m_Pwd << endl;
        }
    }
    else {
        //查看老师
        for (int i = 0; i < vTea.size(); i++) {
            cout << "职工号：" << vTea[i].m_EmpId
                << "  姓名：" << vTea[i].m_Name
                << "  密码：" << vTea[i].m_Pwd << endl;
        }
    }

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

7.3.2 测试

7.4、查看机房

7.4.1 添加机房信息

案例需求中，机房一共有三个，其中

1号机房容量20台机器，

2号50台，

3号100台

我们可以将信息录入到computerRoom.txt中

7.4.2 机房类创建

在头文件下，创建新的文件 computerRoom.h

并添加如下代码

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

class CompeturRoom {
public:
	int m_cId;
	int m_maxNum;
};

7.4.3 初始化机房信息

在Manager管理员类下，添加机房的容器,用于保存机房信息

在初始化容器initVector()中，追加代码：

//读取机房信息
vCom.clear();
ifs.open(COMPUTER_FILE, ios::in);
if (!ifs.is_open()) {
    cout << "文件读取失败！";
    ifs.close();
}

CompeturRoom c;
while (ifs >> c.m_cId && ifs >> c.m_maxNum) {
    vCom.push_back(c);
}

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

7.4.4 显示机房信息

在Manager类的showComputer成员函数中添加如下代码：

//查看机房信息
void Manager::showCompter() {
    cout << "机房信息如下" << endl;
    for (int i = 0; i < vCom.size(); i++) {
        cout << "机房ID：" << vCom[i].m_cId << "  机房最大容量：" << vCom[i].m_maxNum << endl;
    }
    system("pause");
    system("cls");
}

测试：

7.5、清空预约

功能描述：

清空生成的order.txt预约文件

7.5.1 清空功能实现

在Manager的cleanFile成员函数中添加如下代码：

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

    cout << "清空成功！" << endl;
    system("pause");
    system("cls");
}

测试清空，可以随意写入一些信息在order.txt中，然后调用cleanFile清空文件接口，查看是否清空干净

8、学生模块

8.1、学生登录和注销

8.1.1 构造函数

在Student类的构造函数中，初始化学生信息，代码如下：

Student::Student(int id, string name, string pwd){
	this->m_Id = id;
	this->m_Name = name;
	this->m_Pwd = pwd;
}

8.1.2 管理员子菜单

在机房预约系统.cpp中，当用户登录的是学生，添加学生菜单接口
将不同的分支提供出来

申请预约
查看我的预约
查看所有预约
取消预约
注销登录

实现注销功能

在main.cpp中添加全局函数 void studentMenu(Identity * &manager) 代码如下：

//学生菜单
void studentMenu(Identity*& student) {
    //父类指针强制转换为子类指针,以调用子类的成员
    Student* stu = (Student*)student;

    while (true) {

        stu->operMenu();
        int select;
        cin >> select;

        switch (select) {
        case 1:     //申请预约
            stu->applyOrder();
            break;
        case 2:     //查看我的预约
            stu->showMyOrder();
            break;
        case 3:     //查看所有预约
            stu->showAllOrder();
            break;
        case 4:     //取消预约
            stu->cancelOrder();
            break;
        default:
            delete student;
            cout << "注销成功" << endl;
            system("pause");
            system("cls");
            return;

        }
    }
}

8.1.3 菜单功能实现

在实现成员函数void Student::operMenu() 代码如下：

//显示菜单
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;

}

8.1.4 接口对接

学生成功登录后，调用学生的子菜单界面
在loginIn() 学生登录分支中，添加代码：

测试：

8.2、申请预约

8.2.1 获取机房信息

在申请预约时，学生可以看到机房的信息，因此我们需要让学生获取到机房的信息

在student.h中添加新的成员属性如下

在学生类的有参构造函数中追加如下代码：

Student::Student(int id, string name, string pwd){
	this->m_Id = id;
	this->m_Name = name;
	this->m_Pwd = pwd;

    //用容器，获取机房信息
    ifstream ifs(COMPUTER_FILE,ios::in);
    CompeturRoom c;
    while (ifs>>c.m_cId&&ifs>>c.m_maxNum) {
        vCom.push_back(c);
    }

    ifs.close();

}

8.2.2 预约功能实现

在student.cpp中实现成员函数 void Student::applyOrder()

//申请预约
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;
        }
        else {
            cout << "输入错误，请重新输入：" << endl;
        }
    }

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

    cout << "请选择机房：" << endl;
    for (int i = 0; i < vCom.size();i++) {
        cout <<vCom[i].m_cId<<"号机房容量：" << vCom[i].m_maxNum << endl;
    }
    while (true) {
        cin >> room;
        if (room == 1 || room == 2 || room == 3) {
            break;
        }
        else {
            cout << "输入错误，请重新输入：" << endl;
        }
    }
    cout << "预约成功！审核中~~~" << endl;

    //写入文件
    ofstream ofs(ORDER_FILE, ios::out | ios::app);
    if (!ofs.is_open()) {
        cout << "打开文件失败" << endl;
    }
    ofs << "date:" << date << " ";
    ofs << "interval:" << interval << " ";
    ofs << "stuId:" << this->m_Id << " ";
    ofs << "stuName:" << this->m_Name << " ";
    ofs << "roomId:" << room << " ";
    ofs << "status:" << 1 << endl;

    ofs.close();

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

}

8.3、显示预约

8.3.1 创建预约类

功能描述：显示预约记录时，需要从文件中获取到所有记录，用来显示，创建预约的类来管理记录以及更新

在头文件以及源文件下分别创建orderFile.h 和 orderFile.cpp文件

orderFile.h中添加如下代码：

class OrderFile {
public:
	OrderFile();

	//更新预约信息
	void updateOrder();

	//存放预约的容器 int为预约信息的条数，map<string,string>为预约信息的对组
	map<int, map<string, string>> bigM;

	//预约的条数
	int m_size;

};

存储预约信息的容器解释：

声明一个截取字符串函数

OrderFile.cpp中获取所有信息，并存放在容器中，添加如下代码：

//截取字符串
void OrderFile::findSubstr(string baseStr, map<string, string>& m) {

	string key;
	string value;

	//date:1
	int pos = baseStr.find(":");
	if (pos != -1) {
		key = baseStr.substr(0, pos);
		value = baseStr.substr(pos + 1, baseStr.size() - pos - 1);	//6 -4 = 2  2 - 1 = 1
	}
	m.insert(make_pair(key, value));
	
}

OrderFile::OrderFile() {
	ifstream ifs(ORDER_FILE, ios::in);

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

	this->m_size = 0;

	if (!ifs.is_open()) {
		cout << "打开失败！" << endl;
	}
	else {
		while (ifs >> date && ifs >> interval && ifs >> stuId
			&& ifs >> stuName && ifs >> roomId && ifs >> status) {

			map<string, string> m;

			findSubstr(date,m);
			findSubstr(interval, m);
			findSubstr(stuId, m);
			findSubstr(stuName, m);
			findSubstr(roomId, m);
			findSubstr(status, m);

			this->bigM.insert(make_pair(this->m_size, m));
			this->m_size++;
				

		}
	}

	测试代码
	//for (map<int, map<string, string>>::iterator it = bigM.begin(); it != bigM.end();it++)
	//{
	//	cout << "key = " << it->first << " value = " << endl;
	//	for (map<string, string>::iterator mit = it->second.begin(); mit != it->second.end(); mit++)
	//	{
	//		cout << mit->first << " " << mit->second << " ";
	//	}
	//	cout << endl;
	//}

	ifs.close();
}

更新预约记录的成员函数updateOrder代码如下：

//更新预约信息
void OrderFile::updateOrder() {
	if (this->m_size == 0) {
		return;
	}
	else {
		ofstream ofs(ORDER_FILE,ios::out|ios::trunc);

		for (int i = 0; i < this->m_size;i++) {
			ofs << "date:" << this->bigM[i]["date"] << " ";
			ofs << "interval:" << this->bigM[i]["interval"] << " ";
			ofs << "stuId:" << this->bigM[i]["stuId"] << " ";
			ofs << "stuName:" << this->bigM[i]["stuName"] << " ";
			ofs << "roomId:" << this->bigM[i]["roomId"] << " ";
			ofs << "status:" << this->bigM[i]["status"] << endl;
		}

		ofs.close();
	}

}

8.3.2 显示自身预约

在Student类的void Student::showMyOrder()成员函数中，添加如下代码

//查看我的预约
void Student::showMyOrder() {
    OrderFile of;
    if (of.m_size == 0) {
        cout << "没有预约记录" << endl;
        system("pause");
        system("cls");
        return;
    }

    for (int i = 0; i < of.m_size; i++) {

        //string --> int
        //string 调用.c_str() 转为const char*  即c_string
        //使用atoi(),将字符串转为int
        if (this->m_Id == atoi(of.bigM[i]["stuId"].c_str())) {
            cout << "预约日期：周" << of.bigM[i]["date"];
            cout << "  时段：" << (of.bigM[i]["interval"] == "1" ? "上午":"下午");
            cout << "  机房：" << of.bigM[i]["roomId"];
            //0 -取消的预约，1 -审核中，2 -审核通过，-1 - 预约失败，审核未通过
            string status = "状态：";
            switch (atoi(of.bigM[i]["status"].c_str())) {
            case 1:
                status += "审核中~";
                break;
            case 2:
                status += "审核通过";
                break;
            case 0:
                status += "预约取消";
                break;
            case -1:
                status += "预约失败，审核未通过！";
                break;
            }

            cout << "  "<<status << endl;
        }
    }
    system("pause");
    system("cls");
}

测试：

8.3.3 显示所有预约

在Student类的void Student::showAllOrder()成员函数中，添加如下代码

//查看所有预约
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++) {

        //string --> int
        //string 调用.c_str() 转为const char*  即c_string
        //使用atoi(),将字符串转为int
        cout << "预约日期：周" << of.bigM[i]["date"];
        cout << "  时段：" << (of.bigM[i]["interval"] == "1" ? "上午" : "下午");
        cout << "  机房：" << of.bigM[i]["roomId"];
        //0 -取消的预约，1 -审核中，2 -审核通过，-1 - 预约失败，审核未通过
        string status = "状态：";
        switch (atoi(of.bigM[i]["status"].c_str())) {
        case 1:
            status += "审核中~";
            break;
        case 2:
            status += "审核通过";
            break;
        case 0:
            status += "预约取消";
            break;
        case -1:
            status += "预约失败，审核未通过！";
            break;
        }

        cout << "  " << status << endl;
    }
    
    system("pause");
    system("cls");
}

测试：

8.4、取消预约

在Student类的void Student::cancelOrder()成员函数中，添加如下代码

//取消预约
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 (this->m_Id == atoi(of.bigM[i]["stuId"].c_str())) {
            //筛选预约状态
            if (of.bigM[i]["status"] == "1"|| of.bigM[i]["status"] == "2") {
                v.push_back(i);
                cout << index++ << "、";
                cout << "预约日期,周：" << of.bigM[i]["date"];
                cout << "  时间段：" << of.bigM[i]["interval"];
                cout << "  机房：" << of.bigM[i]["roomId"];
                string status = "  状态：";

                if (of.bigM[i]["status"] == "1") {
                    status += "审核中~";
                }
                else if(of.bigM[i]["status"] == "2"){
                    status += "预约成功！";
                }

                cout << status << endl;

            }
        }
    }

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

    while (true) {
        cin >> select;
        if (select >=0 && select<=v.size()) {
            if (select == 0) {
                break;
                cout << "退出成功！" << endl;
            }
            else {
                of.bigM[v[select - 1]]["status"] = "0";
                of.updateOrder();
                cout << "预约已取消！" << endl;
                break;
            } 
        }
        cout << "输入有误，请重新输入:" << endl;

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

测试：

9、教师模块

9.1、教师登录和注销

9.1.1 构造函数

在Teacher类的构造函数中，初始化教师信息，代码如下：

Teacher::Teacher(int Empid, string name,string pwd){
	this->m_EmpId = Empid;
	this->m_Name = name;
	this->m_Pwd = pwd;
}

9.1.2 教师子菜单

在机房预约系统.cpp中，当用户登录的是教师，添加教师菜单接口
将不同的分支提供出来

查看所有预约
审核预约
注销登录

实现注销功能

在main.cpp中添加全局函数 void TeacherMenu(Person * &manager) 代码如下：

//教师菜单
void studentMenu(Identity*& teacher) {
    //父类指针强制转换为子类指针,以调用子类的成员
    Teacher* tea = (Teacher*)teacher;

    while (true) {

        tea->operMenu();
        int select;
        cin >> select;

        switch (select) {
        case 1:     //查看所有预约
            tea->showAllOrder();
            break;
        case 2:     //审核预约
            tea->validOrder();
            break;
        default:
            delete teacher;
            cout << "注销成功" << endl;
            system("pause");
            system("cls");
            return;

        }
    }
}

9.1.3 菜单功能实现

在实现成员函数void Teacher::operMenu() 代码如下：

//教师菜单界面
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;
}

9.1.4 接口对接

教师成功登录后，调用教师的子菜单界面
在教师登录分支中，添加代码：

测试：

9.2、查看所有预约

9.2.1 查看所有预约功能实现

该功能与学生身份的查看所有预约功能相似，用于显示所有预约记录

在Teacher.cpp中实现成员函数 void Teacher::showAllOrder()

//查看所有预约
void Teacher::showAllOrder() {
    OrderFile of;
    if (of.m_size == 0) {
        cout << "没有预约记录" << endl;
        system("pause");
        system("cls");
        return;
    }
    int index = 1;
    for (int i = 0; i < of.m_size; i++) {

        //string --> int
        //string 调用.c_str() 转为const char*  即c_string
        //使用atoi(),将字符串转为int
        cout << index++ << "、";
        cout << "预约日期：周" << of.bigM[i]["date"];
        cout << "  时段：" << (of.bigM[i]["interval"] == "1" ? "上午" : "下午");
        cout << "  机房：" << of.bigM[i]["roomId"];
        //0 -取消的预约，1 -审核中，2 -审核通过，-1 - 预约失败，审核未通过
        string status = "状态：";
        switch (atoi(of.bigM[i]["status"].c_str())) {
        case 1:
            status += "审核中~";
            break;
        case 2:
            status += "审核通过";
            break;
        case 0:
            status += "预约取消";
            break;
        case -1:
            status += "预约失败，审核未通过！";
            break;
        }

        cout << "  " << status << endl;
    }

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

9.2.2 测试功能

运行测试教师身份的查看所有预约功能

测试效果如图：

9.3、审核预约

9.3.1 审核功能实现

功能描述：教师审核学生的预约，依据实际情况审核预约

在Teacher.cpp中实现成员函数 void Teacher::validOrder()

代码如下：

//审核预约
void Teacher::validOrder() {
    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 (of.bigM[i]["status"] == "1"){
            v.push_back(i);
            cout << index++ << " 、";
            cout << "  预约日期,周：" << of.bigM[i]["date"];
            cout << "  时间段：：" << of.bigM[i]["date"];
            cout << "  机房：" << of.bigM[i]["date"];
            cout << "  状态：审核中~" << endl;
        }
    }

    cout << "请输入审核的记录,0,表示返回" << endl;

    int select;
    int ret;

    while (true) {
        cin >> select;
        if (select>=0 && select<=v.size()) {
            if (select == 0) {
                cout << "退出成功！" << endl;
                break;
            }
            else{
                cout << "请输入审核结果:" << endl;
                cout << "1、通过" << endl;
                cout << "2、不通过" << endl;
                cin >> ret;

                if (ret == 1) {
                    of.bigM[v[select - 1]]["status"] = "2";
                }

                else if (ret == 2) {
                    of.bigM[v[select - 1]]["status"] = "-1";
                }
                cout << "审核完毕！" << endl;
                of.updateOrder();
                break;
            }
        }
        cout << "输入有误，请重新输入：" << endl;
    }
    system("pause");
    system("cls");
}

9.3.2 测试审核预约

测试 - 审核通过

至此本案例制作完毕！ ^_^

附源码：

1、资源目录结构

2、头文件

2.1、computerRoom.h

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

class CompeturRoom {
public:
	int m_cId;
	int m_maxNum;
};

2.2、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"

2.3、Identity.h

#pragma once

#include<iostream>
using namespace std;

//身份基类
class Identity {
public:

	//纯虚函数，显示菜单
	virtual void operMenu() = 0;

	//用户名
	string m_Name;
	
	//密码
	string m_Pwd;

};

2.4、Manager.h

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

#include"Identity.h"
#include"globalFile.h"
#include<fstream>
#include<vector>
#include"Student.h"
#include"Teacher.h"
#include"computerRoom.h"

//管理员类设计
class Manager :public Identity {
public:
	//构造函数
	Manager();
	Manager(string name, string pwd);

	//显示管理员操作的菜单界面
	virtual void operMenu();

	//添加账号
	void addPerson();

	//查看账号
	void showPerson();

	//查看机房信息
	void showCompter();

	//清空预约记录
	void cleanFile();

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

	//学生容器
	vector<Student> vStu;

	//老师容器
	vector<Teacher> vTea;

	//机房容器
	vector<CompeturRoom> vCom;

	//检测重复 参数:(传入id，传入类型) 返回值：(true 代表有重复，false代表没有重复)     
	bool checkRepeat(int id, int type);

};

2.5、OrderFile.h

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

#include<map>
#include<fstream>
#include"globalFile.h"

class OrderFile {
public:
	OrderFile();

	//更新预约信息
	void updateOrder();

	//截取字符串
	void findSubstr(string baseStr, map<string, string>& m);

	//存放预约的容器 int为预约信息的条数，map<string,string>为预约信息的对组
	map<int, map<string, string>> bigM;

	//预约的条数
	int m_size;


};

2.6、Student.h

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

#include"Identity.h"
#include"globalFile.h"
#include<fstream>
#include<vector>
#include"Teacher.h"
#include"computerRoom.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<CompeturRoom> vCom;


};

2.7、Teacher.h

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

#include"Identity.h"
#include"globalFile.h"
#include<fstream>
#include<vector>
#include"Student.h"
#include"computerRoom.h"
#include"OrderFile.h"

//老师类设计
class Teacher :public Identity {
public:
	//构造函数
	Teacher();
	Teacher(int Empid, string name, string pwd);

	//显示菜单
	virtual void operMenu();

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

	//审核预约
	void validOrder();	

	//职工号
	int m_EmpId{};


};

3、源文件

3.1、main.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

#include"Identity.h"
#include<fstream>
#include"globalFile.h"
#include"Student.h"
#include"Manager.h"
#include"Teacher.h"



//管理员菜单
void managerMenu(Identity*& manager) {

    //父类指针强制转换为子类指针,以调用子类的成员
    Manager* man = (Manager*)manager;

    while (true) {

        man->operMenu();
        int select;
        cin >> select;

        switch (select) {
        case 1:     //添加账号
            man->addPerson();
            break;
        case 2:     //查看账号
            man->showPerson();
            break;
        case 3:     //查看机房
            man->showCompter();
            break;
        case 4:     //清空预约
            man->cleanFile();
            break;
        default:
            delete manager;
            cout << "注销成功" << endl;
            system("pause");
            system("cls");
            return;

        }
    }

}

//学生菜单
void studentMenu(Identity*& student) {
    //父类指针强制转换为子类指针,以调用子类的成员
    Student* stu = (Student*)student;

    while (true) {

        stu->operMenu();
        int select;
        cin >> select;

        switch (select) {
        case 1:     //申请预约
            stu->applyOrder();
            break;
        case 2:     //查看我的预约
            stu->showMyOrder();
            break;
        case 3:     //查看所有预约
            stu->showAllOrder();
            break;
        case 4:     //取消预约
            stu->cancelOrder();
            break;
        default:
            delete student;
            cout << "注销成功" << endl;
            system("pause");
            system("cls");
            return;

        }
    }
}

//教师菜单
void TeacherMenu(Identity*& teacher) {
    //父类指针强制转换为子类指针,以调用子类的成员
    Teacher* tea = (Teacher*)teacher;

    while (true) {

        tea->operMenu();
        int select;
        cin >> select;

        switch (select) {
        case 1:     //查看所有预约
            tea->showAllOrder();
            break;
        case 2:     //审核预约
            tea->validOrder();
            break;
        default:
            delete teacher;
            cout << "注销成功" << endl;
            system("pause");
            system("cls");
            return;

        }
    }
}


//全局登录验证函数
void loginIn(string fileName,int type) {

    //父类指针,用于实现多态
    Identity* person = NULL;

    ifstream ifs(fileName,ios::in);

    if (!ifs.is_open()) {
        cout << "文件不存在！" << endl;
        ifs.close();
        return;
    }

    int id{};
    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;
        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;
        string fName;
        string fPwd;

        while (ifs>>fId&&ifs>>fName&&ifs>>fPwd) {
            if (id == fId && fName ==name && fPwd == pwd) {
                cout << "教师验证登录成功" << endl;
                system("pause");
                system("cls");
                person = new Teacher(id, name, pwd);
                //进入教师类菜单
                TeacherMenu(person);             
                return;
            }
            
        }
    }
    else if(type == 3){
        //管理员登录验证
        string fName;
        string fPwd;
        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");
    

}



int main() {

	int select; //用于接受用户的输入

	while (true) {
        cout << "======================  欢迎来到qxer机房预约系统  ====================="
            << 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;
}

3.2、Manager.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include"Manager.h"

//构造函数
Manager::Manager() {

}
Manager::Manager(string name, string pwd) {
	this->m_Name = name;
	this->m_Pwd = pwd;
    this->initVector();
}

//显示管理员操作的菜单界面
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 << "\t\t ---------------------------------\n";
    cout << "请选择您的操作： " << endl;

}

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

    string filename;
    string tip;
    string errorTip;

    int select;
    cin >> select;

    if (select == 1) {
        filename = STUDENT_FILE;
        tip = "请输入学号：";
        errorTip = "学号重复，请重新输入：";
    }
    else {
        filename = TEACHER_FILE;
        tip = "请输入职工号：";
        errorTip = "职工号重复，请重新输入：";
    }

    ofstream ofs(filename,ios::out|ios::app);
    int id;
    string name;
    string pwd;

    while (true) {
        cout << tip << endl;
        cin >> id;
        bool ret = checkRepeat(id, select);
        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 Manager::showPerson() {
    cout << "请输入你想查看的用户类型：" << endl;
    cout << "1、查看学生的账号" << endl;
    cout << "2、查看老师的账号" << endl;

    int select;
    cin >> select;

    if (select == 1) {
        //查看学生
        cout << "学生信息如下：" << endl;
        for (int i = 0; i < vStu.size();i++) {
            cout << "学号：" << vStu[i].m_Id 
                << "  姓名：" << vStu[i].m_Name 
                << "  密码：" << vStu[i].m_Pwd << endl;
        }
    }
    else {
        //查看老师
        cout << "老师信息如下：" << endl;
        for (int i = 0; i < vTea.size(); i++) {
            cout << "职工号：" << vTea[i].m_EmpId
                << "  姓名：" << vTea[i].m_Name
                << "  密码：" << vTea[i].m_Pwd << endl;
        }
    }

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

//查看机房信息
void Manager::showCompter() {
    cout << "机房信息如下" << endl;
    for (int i = 0; i < vCom.size(); i++) {
        cout << "机房ID：" << vCom[i].m_cId << "  机房最大容量：" << vCom[i].m_maxNum << endl;
    }
    system("pause");
    system("cls");
}

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

    cout << "清空成功！" << endl;
    system("pause");
    system("cls");
}

void Manager::initVector() {
    //确保读取前，容器为空
    vTea.clear();
    vStu.clear();
    

    ifstream ifs;

    //读取学生信息
    ifs.open(STUDENT_FILE,ios::in);
    if (!ifs.is_open()) {
        cout << "文件读取失败！";
        ifs.close();
    }

    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);
    if (!ifs.is_open()) {
        cout << "文件读取失败！"<<endl;
        ifs.close();
    }

    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();

    //读取机房信息
    vCom.clear();
    ifs.open(COMPUTER_FILE, ios::in);
    if (!ifs.is_open()) {
        cout << "文件读取失败！";
        ifs.close();
    }

    CompeturRoom c;
    while (ifs >> c.m_cId && ifs >> c.m_maxNum) {
        vCom.push_back(c);
    }

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

}

bool Manager::checkRepeat(int id, int type) {
    if (type == 1) {
        //检测学生
        for (int i = 0; i < vStu.size();i++) {
            if (vStu[i].m_Id == id) {
                return true;
            }
        }
    }
    else {
        //检测老师
        for (int i = 0; i < vTea.size(); i++) {
            if (vTea[i].m_EmpId == id) {
                return true;
            }
        }
    }

    return false;
}

3.3、OrderFile.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include"OrderFile.h"

//截取字符串
void OrderFile::findSubstr(string baseStr, map<string, string>& m) {

	string key;
	string value;

	//date:1
	int pos = baseStr.find(":");
	if (pos != -1) {
		key = baseStr.substr(0, pos);
		value = baseStr.substr(pos + 1, baseStr.size() - pos - 1);	//6 -4 = 2  2 - 1 = 1
	}
	m.insert(make_pair(key, value));
	
}

OrderFile::OrderFile() {
	ifstream ifs(ORDER_FILE, ios::in);

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

	this->m_size = 0;

	if (!ifs.is_open()) {
		cout << "打开失败！" << endl;
	}
	else {
		while (ifs >> date && ifs >> interval && ifs >> stuId
			&& ifs >> stuName && ifs >> roomId && ifs >> status) {

			map<string, string> m;

			findSubstr(date,m);
			findSubstr(interval, m);
			findSubstr(stuId, m);
			findSubstr(stuName, m);
			findSubstr(roomId, m);
			findSubstr(status, m);

			this->bigM.insert(make_pair(this->m_size, m));
			this->m_size++;
				

		}
	}

	测试代码
	//for (map<int, map<string, string>>::iterator it = bigM.begin(); it != bigM.end();it++)
	//{
	//	cout << "key = " << it->first << " value = " << endl;
	//	for (map<string, string>::iterator mit = it->second.begin(); mit != it->second.end(); mit++)
	//	{
	//		cout << mit->first << " " << mit->second << " ";
	//	}
	//	cout << endl;
	//}

	ifs.close();
}

//更新预约信息
void OrderFile::updateOrder() {
	if (this->m_size == 0) {
		return;
	}
	else {
		ofstream ofs(ORDER_FILE,ios::out|ios::trunc);

		for (int i = 0; i < this->m_size;i++) {
			ofs << "date:" << this->bigM[i]["date"] << " ";
			ofs << "interval:" << this->bigM[i]["interval"] << " ";
			ofs << "stuId:" << this->bigM[i]["stuId"] << " ";
			ofs << "stuName:" << this->bigM[i]["stuName"] << " ";
			ofs << "roomId:" << this->bigM[i]["roomId"] << " ";
			ofs << "status:" << this->bigM[i]["status"] << endl;
		}

		ofs.close();
	}

}

3.4、Student.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include"Student.h"
#include"OrderFile.h"

//构造函数
Student::Student() {

}
Student::Student(int id, string name, string pwd){
	this->m_Id = id;
	this->m_Name = name;
	this->m_Pwd = pwd;

    //用容器，获取机房信息
    ifstream ifs(COMPUTER_FILE,ios::in);
    CompeturRoom c;
    while (ifs>>c.m_cId&&ifs>>c.m_maxNum) {
        vCom.push_back(c);
    }

    ifs.close();

}

//显示菜单
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;
        }
        else {
            cout << "输入错误，请重新输入：" << endl;
        }
    }

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

    cout << "请选择机房：" << endl;
    for (int i = 0; i < vCom.size();i++) {
        cout <<vCom[i].m_cId<<"号机房容量：" << vCom[i].m_maxNum << endl;
    }
    while (true) {
        cin >> room;
        if (room == 1 || room == 2 || room == 3) {
            break;
        }
        else {
            cout << "输入错误，请重新输入：" << endl;
        }
    }
    cout << "预约成功！审核中~~~" << endl;

    //写入文件
    ofstream ofs(ORDER_FILE,ios::app);
    if (!ofs.is_open()) {
        cout << "打开文件失败" << endl;
    }
    ofs << "date:" << date << " ";
    ofs << "interval:" << interval << " ";
    ofs << "stuId:" << this->m_Id << " ";
    ofs << "stuName:" << this->m_Name << " ";
    ofs << "roomId:" << room << " ";
    ofs << "status:" << 1 << endl;

    ofs.close();
    
    system("pause");
    system("cls");

}

//查看我的预约
void Student::showMyOrder() {
    OrderFile of;
    if (of.m_size == 0) {
        cout << "没有预约记录" << endl;
        system("pause");
        system("cls");
        return;
    }

    int index = 1;
    for (int i = 0; i < of.m_size; i++) {

        //string --> int
        //string 调用.c_str() 转为const char*  即c_string
        //使用atoi(),将字符串转为int
        
        if (this->m_Id == atoi(of.bigM[i]["stuId"].c_str())) {
            cout << index++ << "、";
            cout << "预约日期：周" << of.bigM[i]["date"];
            cout << "  时段：" << (of.bigM[i]["interval"] == "1" ? "上午":"下午");
            cout << "  机房：" << of.bigM[i]["roomId"];
            //0 -取消的预约，1 -审核中，2 -审核通过，-1 - 预约失败，审核未通过
            string status = "状态：";
            switch (atoi(of.bigM[i]["status"].c_str())) {
            case 1:
                status += "审核中~";
                break;
            case 2:
                status += "审核通过";
                break;
            case 0:
                status += "预约取消";
                break;
            case -1:
                status += "预约失败，审核未通过！";
                break;
            }

            cout << "  "<<status << endl;
        }
    }
    system("pause");
    system("cls");
}

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

    int index = 1;
    for (int i = 0; i < of.m_size; i++) {

        //string --> int
        //string 调用.c_str() 转为const char*  即c_string
        //使用atoi(),将字符串转为int
        cout << index++ << "、";
        cout << "预约日期：周" << of.bigM[i]["date"];
        cout << "  时段：" << (of.bigM[i]["interval"] == "1" ? "上午" : "下午");
        cout << "  机房：" << of.bigM[i]["roomId"];
        //0 -取消的预约，1 -审核中，2 -审核通过，-1 - 预约失败，审核未通过
        string status = "状态：";
        switch (atoi(of.bigM[i]["status"].c_str())) {
        case 1:
            status += "审核中~";
            break;
        case 2:
            status += "审核通过";
            break;
        case 0:
            status += "预约取消";
            break;
        case -1:
            status += "预约失败，审核未通过！";
            break;
        }

        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 (this->m_Id == atoi(of.bigM[i]["stuId"].c_str())) {
            //筛选预约状态
            if (of.bigM[i]["status"] == "1"|| of.bigM[i]["status"] == "2") {
                v.push_back(i);
                cout << index++ << "、";
                cout << "预约日期,周：" << of.bigM[i]["date"];
                cout << "  时间段：" << of.bigM[i]["interval"];
                cout << "  机房：" << of.bigM[i]["roomId"];
                string status = "  状态：";

                if (of.bigM[i]["status"] == "1") {
                    status += "审核中~";
                }
                else if(of.bigM[i]["status"] == "2"){
                    status += "预约成功！";
                }

                cout << status << endl;

            }
        }
    }

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

    while (true) {
        cin >> select;
        if (select >=0 && select<=v.size()) {
            if (select == 0) {
                break;
                cout << "退出成功！" << endl;
            }
            else {
                of.bigM[v[select - 1]]["status"] = "0";
                of.updateOrder();
                cout << "预约已取消！" << endl;
                break;
            } 
        }
        cout << "输入有误，请重新输入:" << endl;

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

3.5、Teacher.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include"Teacher.h"

//构造函数
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;
    }
    int index = 1;
    for (int i = 0; i < of.m_size; i++) {

        //string --> int
        //string 调用.c_str() 转为const char*  即c_string
        //使用atoi(),将字符串转为int
        cout << index++ << "、";
        cout << "预约日期：周" << of.bigM[i]["date"];
        cout << "  时段：" << (of.bigM[i]["interval"] == "1" ? "上午" : "下午");
        cout << "  机房：" << of.bigM[i]["roomId"];
        //0 -取消的预约，1 -审核中，2 -审核通过，-1 - 预约失败，审核未通过
        string status = "状态：";
        switch (atoi(of.bigM[i]["status"].c_str())) {
        case 1:
            status += "审核中~";
            break;
        case 2:
            status += "审核通过";
            break;
        case 0:
            status += "预约取消";
            break;
        case -1:
            status += "预约失败，审核未通过！";
            break;
        }

        cout << "  " << status << endl;
    }

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

//审核预约
void Teacher::validOrder() {
    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 (of.bigM[i]["status"] == "1"){
            v.push_back(i);
            cout << index++ << " 、";
            cout << "  预约日期,周：" << of.bigM[i]["date"];
            cout << "  时间段：：" << of.bigM[i]["date"];
            cout << "  机房：" << of.bigM[i]["date"];
            cout << "  状态：审核中~" << endl;
        }
    }

    cout << "请输入审核的记录,0,表示返回" << endl;

    int select;
    int ret;

    while (true) {
        cin >> select;
        if (select>=0 && select<=v.size()) {
            if (select == 0) {
                cout << "退出成功！" << endl;
                break;
            }
            else{
                cout << "请输入审核结果:" << endl;
                cout << "1、通过" << endl;
                cout << "2、不通过" << endl;
                cin >> ret;

                if (ret == 1) {
                    of.bigM[v[select - 1]]["status"] = "2";
                }

                else if (ret == 2) {
                    of.bigM[v[select - 1]]["status"] = "-1";
                }
                cout << "审核完毕！" << endl;
                of.updateOrder();
                break;
            }
        }
        cout << "输入有误，请重新输入：" << endl;
    }
    system("pause");
    system("cls");
}