电梯调度程序

说明：

此次是结对编程项目，其实还是第一次接触。之前都是自己一个人闷头写，想实现什么功能就写什么。但这次接触到结对编程，发现和别人讨论的重要性。两个人商量着来，分析用户需求，完善功能。而且两个人商量也不会像一个人找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");
}