电梯调度程序

说明：

此次是结对编程项目，其实还是第一次接触。之前都是自己一个人闷头写，想实现什么功能就写什么。但这次接触到结对编程，发现和别人讨论的重要性。两个人商量着来，分析用户需求，完善功能。而且两个人商量也不会像一个人找bug时那么的焦虑、着急。同时，也是最重要的，结对编程的方式对程序的质量也会有很大的提高。

一、题目要求：

现有一新建办公大厦，共有21层，共有四部电梯，所有电梯基本参数如下表所示：

电梯编号	可服务楼层	最大乘客数量	最大载重量
1	全部楼层	10	800 kg
2	单层	10	800 kg
3	双层	20	1600 kg
4	全部楼层	20	2000 kg

其使用规定如下：

1、楼层号为0~20，其中0号为地下一层；

2、有楼层限制的电梯不在响应楼层停靠，如单双层；

3、所有电梯采用统一按钮控制

请根据上述要求设计并实现一个电梯控制程序，如果有图形显示就更好了。

二、需求分析：

1、共有4部电梯，分单双层停靠和全部楼层都停靠。

2、用户在任意层请求，距离最近的电梯响应乘客要求。

3、随时显示各个电梯运行状态和所在层数。

4、判断电梯人数，防止超重。电梯如果超重不接受外部请求，只接受电梯内部请求。

5、随时接受用户输入，电梯可以同时运行。

三、功能实现：

1、电梯数据结构：

其中各个数据作用已在注释中说明

struct elevator
{
int maxPeople;//电梯最大载重量
int nowPeople;//电梯目前装载4人数
int ifFloor;//是否超载（已满1、未满0）
int serveFloor;//电梯服务楼层（全部3、单层1、双层0）
int outPeople[21];//外部人按电梯请求楼层（数组下标表示楼层，数值值表示是否停靠。停靠1、不停靠-1）
int inPeople[21];//电梯内部人按电梯请求楼层
int staut;//上升1、下降-1、停止0
int floor;//电梯目前楼层
};

2、初始化函数

4部电梯最初都不处于服务状态。即outPeople[21]={-1}、inPeople[21]={-1}；电梯内最初人数nowPeople=0；根据每部电梯的载重量和服务楼层再分别赋值。其中每部电梯的起始楼层是不同的，考虑用户请求要及时相应尽量等较少时间方面的考虑，一号电梯最初在20、二号在9、三号在10、四号在1。

void Iint()//各个电梯初始化
{
for (int i=0; i < 4; i++)
{
for (int j = 0; j < 21; j++)
{
a[i].inPeople[j] = -1;
a[i].outPeople[j] = -1;
}
a[i].nowPeople = 0;
a[i].ifFloor = 0;
}
a[0].maxPeople = 10;
a[0].serveFloor = 3;
a[0].staut = 0;
a[0].floor = 20;
a[1].maxPeople = 10;
a[1].serveFloor = 1;
a[1].staut = 0;
a[1].floor = 9;
a[2].maxPeople = 20;
a[2].serveFloor = 0;
a[2].staut = 0;
a[2].floor = 10;
a[3].maxPeople = 20;
a[3].serveFloor = 3;
a[3].staut = 0;
a[3].floor = 1;
}

3、判断超载

关于电梯的超载部分我是用人数控制的，感觉上电梯的人还要自己录入体重这一点很不人性化，所以采用人数控制的方式。具体的实现是用电梯结构体elevator中的nowpeople（电梯内现在的人数）和maxPeople（电梯最大装载人数）来控制。nowPeople>maxPeople时说明电梯超重，使ifFloor=1，让电梯处于不接受外部响应状态。

void ifFull(int i)//判断电梯是否超载
{
if (a[i].maxPeople < a[i].nowPeople)
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
gotoxy(hOut, 0, 4);
cout << "电梯已满！" << endl;
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
a[i].ifFloor = 1;
return;
}
else
{
a[i].ifFloor = 0;
return;
}
}

4、查询电梯状态

函数为int类型，如果此电梯响应用户返回1，否则返回0。因为是电梯外部人员按电梯，电梯是否相应最开始就要判断电梯是否超重。由于每部电梯的服务楼层不同（全部、单、双），要在电梯是否响应前判断此电梯是否到达用户所在楼层。方法是用户所在楼层对2取余，判断单双层。这两个基本的问题判断完成后还要查询电梯状态，分为以下三种情况：

（1）电梯处于静止状态，无论用户上楼下楼都响应；

（2）电梯处于上升状态，要同时满足用户要上楼，且用户所在楼层比电梯所在楼层高这两个条件；

（3）电梯处于下降状态，要同时满足用户要下楼，且用户所在楼层比电梯所在楼层低这两个条件。

满足以上状态的电梯可以相应用户要求。

int ifSever(int floor, int direction, int elevator)//判断电梯是否相应此用户
{
if (a[elevator].ifFloor == 0)//不超载
{
if (a[elevator].serveFloor == 3 || floor % 2 == a[elevator].serveFloor)//全部和双层
{
if (a[elevator].staut == 0)//停止状态
return 1;
if (a[elevator].staut == 1 && a[elevator].staut == direction)//上升且用户也上升
{
if (a[elevator].floor <= floor)
return 1;
else
return 0;
}
if (a[elevator].staut == -1 && a[elevator].staut == direction)//下降且用户也下降
{
if (a[elevator].floor >= floor)
return 1;
else
return 0;
}
return 0;
}
else
return 0;
}
else
return 0;
}

5、判断最短距离

函数为int类型，电梯有空闲能为电梯服务返回1，否则返回0。使用循环，调用函数int ifSever(int floor, int direction, int elevator)，判断电梯是否能为用户服务，如果可以求出最短距离，并存入数组min[4]中，最后找出数组的最小值，确定响应用户服务的电梯。并把此电梯的outPeople[用户请求楼层]赋值为1，同时如果为静止状态，根据用户请求更改状态。

int search(int floor,int direction)//查询哪个电梯为用户服务
{
int min[4] = { 100, 100, 100, 100 };
int flag;
int x;
for (int i = 0; i < 4; i++)
{
flag = ifSever(floor, direction, i);
if (flag==1)//计算电梯运行距离
{
x = a[i].floor - floor;
min[i] = number(x);
}
else
continue;
}
int temp, num;
temp = min[0];
num = 0;//标记电梯号
for (int i = 1; i < 4; i++)//计算最近楼层
{
if (min[i] < temp)
{
temp = min[i];
num = i;
}
}
if (temp != 100)
{
a[num].outPeople[floor] = 1;
if (a[num].staut==0)
{
if (a[num].floor > floor)
a[num].staut = -1;
if (a[num].floor < floor)
a[num].staut = 1;
if (a[num].floor == floor)
a[num].staut = direction;
}
return 1;
}
return 0;
}

6、用户输入

用户需输入所在楼层和方向，根据用户输入调用查询函数。

void Inset()//用户输入
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
int peopleFloor, peopleDirection, flag;
gotoxy(hOut, 0, 2);
cout << "输入请求的楼层数和方向（1为向上，-1为向下）";
cin >> peopleFloor;
cin >> peopleDirection;
gotoxy(hOut, 0, 2);
cout << "                                                      ";
flag = search(peopleFloor, peopleDirection);
if (flag == 1)//如果查询到服务的电梯
return;
else
{
while (flag == 0)
{
change();
flag = search(peopleFloor, peopleDirection);
}
}
}

7、乘客进入电梯

最初要更改outPeople[floor]=-1，使用户输入目的楼层，判断此电梯是否到达目的楼层，不到达则不响应用户要求，否则更改inPeople[用户到达楼层]=1。此时也要调用电梯超载函数，实时更新电梯状态。

void getIn(int i)//进入电梯
{
a[i].outPeople[a[i].floor] = -1;
int flag1, flag2;
flag1 = 1;
flag2 = 1;
for (int j = 0; j < 21; j++)//电梯是否需要继续运行
{
if (flag1 == 1 && a[i].inPeople[j] == -1)
continue;
else
{
flag1 = 0;
break;
}
}
for (int j = 0; j < 21; j++)
{
if (flag2 == 1 && a[i].outPeople[j] == -1)
continue;
else
{
flag2 = 0;
break;
}
}
if (flag1 == 1 && flag2 == 1)
a[i].staut = 0;
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
int f;
gotoxy(hOut, 0, 3);
cout << "输入目的层数";
cin >> f;
gotoxy(hOut, 0, 3);
cout << "                                                      ";
if (f % 2 == a[i].serveFloor || a[i].serveFloor == 3)//此电梯是否到目的层
{
a[i].nowPeople++;
ifFull(i);
if (a[i].staut == 0)//电梯如果是暂停状态，更改目的状态
{
if (a[i].floor > f)
a[i].staut = -1;
if (a[i].floor < f)
a[i].staut = 1;
}
a[i].inPeople[f] = 1;//标记目的层数
}
else
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
gotoxy(hOut, 0, 4);
cout << "此电梯不到目的层";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
}
}

8、乘客出电梯

调用超载函数，更新电梯状态。更改inPeople[floor] = -1。

void getOut(int i)//出电梯
{
a[i].nowPeople--;
ifFull(i);
a[i].inPeople[a[i].floor] = -1;
}

9、电梯状态更新

此部分也分为三种情况：

（1）电梯为静止状态，不需改变；

（2）电梯为上升状态，电梯所在楼层+1，实时判断所在楼层是否需要停靠，如果需要停靠还要判断电梯是否还需继续运行；

（3）电梯为下降状态，电梯所在楼层-1，实时判断所在楼层是否需要停靠，如果需要停靠还要判断电梯是否还需继续运行。

void change()//更新电梯状态
{
int flag1, flag2, i;
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
for (i = 0; i < 4; i++)
{
flag1 = 1;
flag2 = 1;
if (a[i].staut == 1)//上升状态的电梯
{
if (a[i].inPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客出电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getOut(i);
}
if (a[i].outPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客进入电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getIn(i);
}
for (int j = 0; j < 21; j++)//判断电梯是否需要继续运行
{
if (flag1 == 1 && a[i].inPeople[j] == -1)
continue;
else
{
flag1 = 0;
break;
}
}
for (int j = 0; j < 21; j++)
{
if (flag2 == 1 && a[i].outPeople[j] == -1)
continue;
else
{
flag2 = 0;
break;
}
}
if (flag1 == 1 && flag2 == 1)
a[i].staut = 0;
else
a[i].floor++;//电梯继续上行
}
if (a[i].staut == -1)//下降状态的电梯
{
if (a[i].inPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客出电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getOut(i);
}
if (a[i].outPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客进入电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getIn(i);
}
for (int j = 0; j < 21; j++)//电梯是否需要继续运行
{
if (flag1 == 1 && a[i].inPeople[j] == -1)
continue;
else
{
flag1 = 0;
break;
}
}
for (int j = 0; j < 21; j++)
{
if (flag2 == 1 && a[i].outPeople[j] == -1)
continue;
else
{
flag2 = 0;
break;
}
}
if (flag1 == 1 && flag2 == 1)
a[i].staut = 0;
else
a[i].floor--;//电梯继续下降
}
}
display();
}

10、显示功能

这一部分我们两个人也是讨论了很久，由于一直在输入和输出会使界面显得特别乱。最终决定用光标定位的方式，每次都在同样的地方输入，覆盖原来的部分。具体实现如下：

void gotoxy(HANDLE hOut, int x, int y)//光标移到指定位置
{
COORD pos;
pos.X = x;             //横坐标
pos.Y = y;            //纵坐标
SetConsoleCursorPosition(hOut, pos);
}

在显示函数中，主要就是实时更新显示电梯状态。静止用"__"表示；上升用 "↑"表示；下降用"↓"表示。

void display()//结果显示
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
for (int i = 0, j = 0; i < 4; i++,j=j+6)
{
gotoxy(hOut, j, 0);
if (a[i].staut == 1)
{
if (a[i].floor>=10)
cout << "↑" << a[i].floor;
else
cout << "↑0" << a[i].floor;
}
if (a[i].staut == 0)
{
if (a[i].floor >= 10)
cout << "__" << a[i].floor;
else
cout << "__0" << a[i].floor;
}
if (a[i].staut == -1)
{
if (a[i].floor >= 10)
cout << "↓" << a[i].floor;
else
cout << "↓0" << a[i].floor;
}
}
}

11、主函数

主函数是一个while的永真循环，不断接受用户输入，实时更新电梯状态。

void main()
{
Iint();
display();
char c;
while (1)
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
gotoxy(hOut, 0, 1);
cout << "是否输入";
cin >> c;
if (c == 'y')
Inset();
change();
}
system("pause");
}

四、调试分析

1、开始执行状态：



2、 用户输入：8 -1（8楼有下楼请求）



3、3号电梯相应



4、此时有又用户请求：6 -1（6楼有用户下楼）



5、3号电梯距离最近，依旧3号电梯相应



6、乘客输入1，3号电梯为双层服务，不到1楼



7、另一用户到4层，目的楼层到达



8、用户已到达电梯停止运行



9、以下是多个电梯的同时运行的情况，过程同上，就不做具体说明了









五、总结

1、对程序的总结：

刚开始时不知从何下手，最棘手的问题就是电梯需要运行又要随时接受用户输入。这个问题我和队友讨论了很久，最终决定用一个永真循环，每次电梯状态更新都让用户输入是否有请求。关于查询服务电梯，我们采用就近原则，只要电梯不是超载，距离最近的电梯相应用户请求。当然这个程序还存在一定的不足，根据这个算法的实现，就是用户如果想上楼就只查询向上运行和静止状态的电梯。例如：用户在11层有下楼请求，有一个电梯在11层向上运行，而运行到12层是最后一个用户。对于这种情况这个电梯是对于11层用户最近的请求，但是这种情况没有考虑在列。我会和队友继续讨论，寻找解决办法。

2、对队友的评价：

此次是结对编程项目，其实还是第一次接触。之前都是自己一个人闷头写，想实现什么功能就写什么。但这次接触到结对编程，发现和别人讨论的重要性。两个人商量着来，分析用户需求，完善功能。而且两个人商量也不会像一个人找bug时那么的焦虑、着急。同时，也是最重要的，结对编程的方式对程序的质量也会有很大的提高。我觉得我的队友工作认真，踏实肯干。和他一起讨论问题也觉得效率很高，问题解决的也很容易顺利。关于电梯的结构体都是商量讨论统一后开始编程的。并且商讨了最终使用的调度算法。他主要负责编写用户输入和显示部分。他挺注重代码效率和规范，命名都清楚明了，而且有简单的注视。对于显示界面也挺美观，显示过的提示用光标定位的办法清除，使界面看起来简单明了。这次也是我意识到讨论的重要性。因为我们平时都在图书馆研修室一起上自习，彼此之间也很熟悉，讨论起来也很方便。这是一次不错也很有意义的经历。

附录：

队友：牛睿杰 博客链接：http://www.cnblogs.com/niuniu11/p/5370409.html



源程序：

#include<iostream>
#include<Windows.h>
#include <conio.h>
using namespace std;
struct elevator
{
int maxPeople;
int nowPeople;
int ifFloor;//已满1、未满0
int serveFloor;//全部3、单层1、双层0
int outPeople[21];
int inPeople[21];
int staut;//上升1、下降-1、停止0
int floor;
};
struct elevator a[4];
int number(int x)//取绝对值
{
if (x < 0)
return -x;
else
return x;
}
void Iint()//各个电梯初始化
{
for (int i=0; i < 4; i++)
{
for (int j = 0; j < 21; j++)
{
a[i].inPeople[j] = -1;
a[i].outPeople[j] = -1;
}
a[i].nowPeople = 0;
a[i].ifFloor = 0;
}
a[0].maxPeople = 10;
a[0].serveFloor = 3;
a[0].staut = 0;
a[0].floor = 20;
a[1].maxPeople = 10;
a[1].serveFloor = 1;
a[1].staut = 0;
a[1].floor = 9;
a[2].maxPeople = 20;
a[2].serveFloor = 0;
a[2].staut = 0;
a[2].floor = 10;
a[3].maxPeople = 20;
a[3].serveFloor = 3;
a[3].staut = 0;
a[3].floor = 1;
}void gotoxy(HANDLE hOut, int x, int y)//光标移到指定位置
{
COORD pos;
pos.X = x;             //横坐标
pos.Y = y;            //纵坐标
SetConsoleCursorPosition(hOut, pos);
}void ifFull(int i)//判断电梯是否超载
{
if (a[i].maxPeople < a[i].nowPeople)
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
gotoxy(hOut, 0, 4);
cout << "电梯已满！" << endl;
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
a[i].ifFloor = 1;
return;
}
else
{
a[i].ifFloor = 0;
return;
}
}void getIn(int i)//进入电梯
{
a[i].outPeople[a[i].floor] = -1;
int flag1, flag2;
flag1 = 1;
flag2 = 1;
for (int j = 0; j < 21; j++)//电梯是否需要继续运行
{
if (flag1 == 1 && a[i].inPeople[j] == -1)
continue;
else
{
flag1 = 0;
break;
}
}
for (int j = 0; j < 21; j++)
{
if (flag2 == 1 && a[i].outPeople[j] == -1)
continue;
else
{
flag2 = 0;
break;
}
}
if (flag1 == 1 && flag2 == 1)
a[i].staut = 0;
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
int f;
gotoxy(hOut, 0, 3);
cout << "输入目的层数";
cin >> f;
gotoxy(hOut, 0, 3);
cout << "                                                      ";
if (f % 2 == a[i].serveFloor || a[i].serveFloor == 3)//此电梯是否到目的层
{
a[i].nowPeople++;
ifFull(i);
if (a[i].staut == 0)//电梯如果是暂停状态，更改目的状态
{
if (a[i].floor > f)
a[i].staut = -1;
if (a[i].floor < f)
a[i].staut = 1;
}
a[i].inPeople[f] = 1;//标记目的层数
}
else
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
gotoxy(hOut, 0, 4);
cout << "此电梯不到目的层";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
}
}void getOut(int i)//出电梯
{
a[i].nowPeople--;
ifFull(i);
a[i].inPeople[a[i].floor] = -1;
}void display()//结果显示
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
for (int i = 0, j = 0; i < 4; i++,j=j+6)
{
gotoxy(hOut, j, 0);
if (a[i].staut == 1)
{
if (a[i].floor>=10)
cout << "↑" << a[i].floor;
else
cout << "↑0" << a[i].floor;
}
if (a[i].staut == 0)
{
if (a[i].floor >= 10)
cout << "__" << a[i].floor;
else
cout << "__0" << a[i].floor;
}
if (a[i].staut == -1)
{
if (a[i].floor >= 10)
cout << "↓" << a[i].floor;
else
cout << "↓0" << a[i].floor;
}
}
}void change()//更新电梯状态
{
int flag1, flag2, i;
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
for (i = 0; i < 4; i++)
{
flag1 = 1;
flag2 = 1;
if (a[i].staut == 1)//上升状态的电梯
{
if (a[i].inPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客出电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getOut(i);
}
if (a[i].outPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客进入电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getIn(i);
}
for (int j = 0; j < 21; j++)//判断电梯是否需要继续运行
{
if (flag1 == 1 && a[i].inPeople[j] == -1)
continue;
else
{
flag1 = 0;
break;
}
}
for (int j = 0; j < 21; j++)
{
if (flag2 == 1 && a[i].outPeople[j] == -1)
continue;
else
{
flag2 = 0;
break;
}
}
if (flag1 == 1 && flag2 == 1)
a[i].staut = 0;
else
a[i].floor++;//电梯继续上行
}
if (a[i].staut == -1)//下降状态的电梯
{
if (a[i].inPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客出电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getOut(i);
}
if (a[i].outPeople[a[i].floor] == 1)
{
gotoxy(hOut, 0, 4);
cout << a[i].floor << "到了！ 乘客进入电梯";
Sleep(1000);
gotoxy(hOut, 0, 4);
cout << "                                                      ";
getIn(i);
}
for (int j = 0; j < 21; j++)//电梯是否需要继续运行
{
if (flag1 == 1 && a[i].inPeople[j] == -1)
continue;
else
{
flag1 = 0;
break;
}
}
for (int j = 0; j < 21; j++)
{
if (flag2 == 1 && a[i].outPeople[j] == -1)
continue;
else
{
flag2 = 0;
break;
}
}
if (flag1 == 1 && flag2 == 1)
a[i].staut = 0;
else
a[i].floor--;//电梯继续下降
}
}
display();
}int ifSever(int floor, int direction, int elevator)//判断电梯是否相应此用户
{
if (a[elevator].ifFloor == 0)//不超载
{
if (a[elevator].serveFloor == 3 || floor % 2 == a[elevator].serveFloor)//全部和双层
{
if (a[elevator].staut == 0)//停止状态
return 1;
if (a[elevator].staut == 1 && a[elevator].staut == direction)//上升且用户也上升
{
if (a[elevator].floor <= floor)
return 1;
else
return 0;
}
if (a[elevator].staut == -1 && a[elevator].staut == direction)//下降且用户也下降
{
if (a[elevator].floor >= floor)
return 1;
else
return 0;
}
return 0;
}
else
return 0;
}
else
return 0;
}int search(int floor,int direction)//查询哪个电梯为用户服务
{
int min[4] = { 100, 100, 100, 100 };
int flag;
int x;
for (int i = 0; i < 4; i++)
{
flag = ifSever(floor, direction, i);
if (flag==1)//计算电梯运行距离
{
x = a[i].floor - floor;
min[i] = number(x);
}
else
continue;
}
int temp, num;
temp = min[0];
num = 0;//标记电梯号
for (int i = 1; i < 4; i++)//计算最近楼层
{
if (min[i] < temp)
{
temp = min[i];
num = i;
}
}
if (temp != 100)
{
a[num].outPeople[floor] = 1;
if (a[num].staut==0)
{
if (a[num].floor > floor)
a[num].staut = -1;
if (a[num].floor < floor)
a[num].staut = 1;
if (a[num].floor == floor)
a[num].staut = direction;
}
return 1;
}
return 0;
}void Inset()//用户输入
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
int peopleFloor, peopleDirection, flag;
gotoxy(hOut, 0, 2);
cout << "输入请求的楼层数和方向（1为向上，-1为向下）";
cin >> peopleFloor;
cin >> peopleDirection;
gotoxy(hOut, 0, 2);
cout << "                                                      ";
flag = search(peopleFloor, peopleDirection);
if (flag == 1)//如果查询到服务的电梯
return;
else
{
while (flag == 0)
{
change();
flag = search(peopleFloor, peopleDirection);
}
}
}void main()
{
Iint();
display();
char c;
while (1)
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
gotoxy(hOut, 0, 1);
cout << "是否输入";
cin >> c;
if (c == 'y')
Inset();
change();
}
system("pause");
}