结对编程电梯调度程序

这次老师安排的是结对编程作业，也是第一次接触两人结对编程，感觉比较新鲜，有感觉难以入手，在经过协商之后，我们一起完成了我们的编程作业，感觉到很开心，也体会到合作的愉快，这是我们这次的成果。

这是这次的题目，感觉操控4个电梯比较困难，而且考虑情况很多，所以我们在做了很多的构想以后，我们才开始编写程序。

  1 #include<iostream>
  2 #include<Windows.h>
  3 #include <conio.h>
  4 using namespace std;
  5 struct elevator
  6 {
  7     int maxPeople;
  8     int nowPeople;
  9     int ifFloor;//已满1、未满0
 10     int serveFloor;//全部3、单层1、双层0
 11     int outPeople[21];
 12     int inPeople[21];
 13     int staut;//上升1、下降-1、停止0
 14     int floor;
 15 };
 16 struct elevator a[4];
 17 int number(int x)//取绝对值
 18 {
 19     if (x < 0)
 20         return -x;
 21     else
 22         return x;
 23 }
 24 void Iint()//各个电梯初始化
 25 {
 26     for (int i=0; i < 4; i++)
 27     {
 28         for (int j = 0; j < 21; j++)
 29         {
 30             a[i].inPeople[j] = -1;
 31             a[i].outPeople[j] = -1;
 32         }
 33         a[i].nowPeople = 0;
 34         a[i].ifFloor = 0;
 35     }
 36     a[0].maxPeople = 10;
 37     a[0].serveFloor = 3;
 38     a[0].staut = 0;
 39     a[0].floor = 20;
 40     a[1].maxPeople = 10;
 41     a[1].serveFloor = 1;
 42     a[1].staut = 0;
 43     a[1].floor = 9;
 44     a[2].maxPeople = 20;
 45     a[2].serveFloor = 0;
 46     a[2].staut = 0;
 47     a[2].floor = 10;
 48     a[3].maxPeople = 20;
 49     a[3].serveFloor = 3;
 50     a[3].staut = 0;
 51     a[3].floor = 1;
 52 }
 53 void gotoxy(HANDLE hOut, int x, int y)//光标移到指定位置
 54 {
 55     COORD pos;
 56     pos.X = x;             //横坐标
 57     pos.Y = y;            //纵坐标
 58     SetConsoleCursorPosition(hOut, pos);
 59 }
 60 void ifFull(int i)//判断电梯是否超载
 61 {
 62     if (a[i].maxPeople < a[i].nowPeople)
 63     {
 64         HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
 65         gotoxy(hOut, 0, 4);
 66         cout << "电梯已满！" << endl;
 67         Sleep(1000);
 68         gotoxy(hOut, 0, 4);
 69         cout << "                                                      ";
 70         a[i].ifFloor = 1;
 71         return;
 72     }
 73     else
 74     {
 75         a[i].ifFloor = 0;
 76         return;
 77     }
 78 }
 79 void getIn(int i)//进入电梯
 80 {
 81     a[i].outPeople[a[i].floor] = -1;
 82     int flag1, flag2;
 83     flag1 = 1;
 84     flag2 = 1;
 85     for (int j = 0; j < 21; j++)//电梯是否需要继续运行
 86     {
 87         if (flag1 == 1 && a[i].inPeople[j] == -1)
 88             continue;
 89         else
 90         {
 91             flag1 = 0;
 92             break;
 93         }
 94     }
 95     for (int j = 0; j < 21; j++)
 96     {
 97         if (flag2 == 1 && a[i].outPeople[j] == -1)
 98             continue;
 99         else
100         {
101             flag2 = 0;
102             break;
103         }
104     }
105     if (flag1 == 1 && flag2 == 1)
106         a[i].staut = 0;
107     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
108     int f;
109     gotoxy(hOut, 0, 3);
110     cout << "输入目的层数";
111     cin >> f;
112     gotoxy(hOut, 0, 3);
113     cout << "                                                      ";
114     if (f % 2 == a[i].serveFloor || a[i].serveFloor == 3)//此电梯是否到目的层
115     {
116         a[i].nowPeople++;
117         ifFull(i);
118         if (a[i].staut == 0)//电梯如果是暂停状态，更改目的状态
119         {
120             if (a[i].floor > f)
121                 a[i].staut = -1;
122             if (a[i].floor < f)
123                 a[i].staut = 1;
124         }
125         a[i].inPeople[f] = 1;//标记目的层数
126     }
127     else
128     {
129         HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
130         gotoxy(hOut, 0, 4);
131         cout << "此电梯不到目的层";
132         Sleep(1000);
133         gotoxy(hOut, 0, 4);
134         cout << "                                                      ";
135     }
136 }
137 void getOut(int i)//出电梯
138 {
139     a[i].nowPeople--;
140     ifFull(i);
141     a[i].inPeople[a[i].floor] = -1;
142 }
143 void display()//结果显示
144 {
145     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
146     for (int i = 0, j = 0; i < 4; i++,j=j+6)
147     {
148         gotoxy(hOut, j, 0);
149         if (a[i].staut == 1)
150         {
151             if (a[i].floor>=10)
152                 cout << "↑" << a[i].floor;
153             else
154                 cout << "↑0" << a[i].floor;
155         }
156         if (a[i].staut == 0)
157         {
158             if (a[i].floor >= 10)
159                 cout << "__" << a[i].floor;
160             else
161                 cout << "__0" << a[i].floor;
162         }
163         if (a[i].staut == -1)
164         {
165             if (a[i].floor >= 10)
166                 cout << "↓" << a[i].floor;
167             else
168                 cout << "↓0" << a[i].floor;
169         }
170     }
171 }
172 void change()//更新电梯状态
173 {
174     int flag1, flag2, i;
175     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
176     for (i = 0; i < 4; i++)
177     {
178         flag1 = 1;
179         flag2 = 1;
180         if (a[i].staut == 1)//上升状态的电梯
181         {
182             if (a[i].inPeople[a[i].floor] == 1)
183             {
184                 gotoxy(hOut, 0, 4);
185                 cout << a[i].floor << "到了！ 乘客出电梯";
186                 Sleep(1000);
187                 gotoxy(hOut, 0, 4);
188                 cout << "                                                      ";
189                 getOut(i);
190             }
191             if (a[i].outPeople[a[i].floor] == 1)
192             {
193                 gotoxy(hOut, 0, 4);
194                 cout << a[i].floor << "到了！ 乘客进入电梯";
195                 Sleep(1000);
196                 gotoxy(hOut, 0, 4);
197                 cout << "                                                      ";
198                 getIn(i);
199             }
200             for (int j = 0; j < 21; j++)//判断电梯是否需要继续运行
201             {
202                 if (flag1 == 1 && a[i].inPeople[j] == -1)
203                     continue;
204                 else
205                 {
206                     flag1 = 0;
207                     break;
208                 }
209             }
210             for (int j = 0; j < 21; j++)
211             {
212                 if (flag2 == 1 && a[i].outPeople[j] == -1)
213                     continue;
214                 else
215                 {
216                     flag2 = 0;
217                     break;
218                 }
219             }
220             if (flag1 == 1 && flag2 == 1)
221                 a[i].staut = 0;
222             else
223                 a[i].floor++;//电梯继续上行
224         }
225         if (a[i].staut == -1)//下降状态的电梯
226         {
227             if (a[i].inPeople[a[i].floor] == 1)
228             {
229                 gotoxy(hOut, 0, 4);
230                 cout << a[i].floor << "到了！ 乘客出电梯";
231                 Sleep(1000);
232                 gotoxy(hOut, 0, 4);
233                 cout << "                                                      ";
234                 getOut(i);
235             }
236             if (a[i].outPeople[a[i].floor] == 1)
237             {
238                 gotoxy(hOut, 0, 4);
239                 cout << a[i].floor << "到了！ 乘客进入电梯";
240                 Sleep(1000);
241                 gotoxy(hOut, 0, 4);
242                 cout << "                                                      ";
243                 getIn(i);
244             }
245             for (int j = 0; j < 21; j++)//电梯是否需要继续运行
246             {
247                 if (flag1 == 1 && a[i].inPeople[j] == -1)
248                     continue;
249                 else
250                 {
251                     flag1 = 0;
252                     break;
253                 }
254             }
255             for (int j = 0; j < 21; j++)
256             {
257                 if (flag2 == 1 && a[i].outPeople[j] == -1)
258                     continue;
259                 else
260                 {
261                     flag2 = 0;
262                     break;
263                 }
264             }
265             if (flag1 == 1 && flag2 == 1)
266                 a[i].staut = 0;
267             else
268                 a[i].floor--;//电梯继续下降
269         }
270     }
271     display();
272 }
273 int ifSever(int floor, int direction, int elevator)//判断电梯是否相应此用户
274 {
275     if (a[elevator].ifFloor == 0)//不超载
276     {
277         if (a[elevator].serveFloor == 3 || floor % 2 == a[elevator].serveFloor)//全部和双层
278         {
279             if (a[elevator].staut == 0)//停止状态
280                 return 1;
281             if (a[elevator].staut == 1 && a[elevator].staut == direction)//上升且用户也上升
282             {
283                 if (a[elevator].floor <= floor)
284                     return 1;
285                 else
286                     return 0;
287             }
288             if (a[elevator].staut == -1 && a[elevator].staut == direction)//下降且用户也下降
289             {
290                 if (a[elevator].floor >= floor)
291                     return 1;
292                 else
293                     return 0;
294             }
295             return 0;
296         }
297         else
298             return 0;
299     }
300     else
301         return 0;
302 }
303 int search(int floor,int direction)//查询哪个电梯为用户服务
304 {
305     int min[4] = { 100, 100, 100, 100 };
306     int flag;
307     int x;
308     for (int i = 0; i < 4; i++)
309     {
310         flag = ifSever(floor, direction, i);
311         if (flag==1)//计算电梯运行距离
312         {
313             x = a[i].floor - floor;
314             min[i] = number(x);
315         }
316         else
317             continue;
318     }
319     int temp, num;
320     temp = min[0];
321     num = 0;//标记电梯号
322     for (int i = 1; i < 4; i++)//计算最近楼层
323     {
324         if (min[i] < temp)
325         {
326             temp = min[i];
327             num = i;
328         }
329     }
330     if (temp != 100)
331     {
332         a[num].outPeople[floor] = 1;
333         if (a[num].staut==0)
334         {
335             if (a[num].floor > floor)
336                 a[num].staut = -1;
337             if (a[num].floor < floor)
338                 a[num].staut = 1;
339             if (a[num].floor == floor)
340                 a[num].staut = direction;
341         }
342         return 1;
343     }
344     return 0;
345 }
346 void Inset()//用户输入
347 {
348     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量
349     int peopleFloor, peopleDirection, flag;
350     gotoxy(hOut, 0, 2);
351     cout << "输入请求的楼层数和方向（1为向上，-1为向下）";
352     cin >> peopleFloor;
353     cin >> peopleDirection;
354     gotoxy(hOut, 0, 2);
355     cout << "                                                      ";
356     flag = search(peopleFloor, peopleDirection);
357     if (flag == 1)//如果查询到服务的电梯
358         return;
359     else
360     {
361         while (flag == 0)
362         {
363             change();
364             flag = search(peopleFloor, peopleDirection);
365         }
366     }
367 }
368 void main()
369 {
370     Iint();
371     display();
372     char c;
373     while (1)
374     {
375         HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
376         gotoxy(hOut, 0, 1);
377         cout << "是否输入";
378         cin >> c;
379         if (c == 'y')
380             Inset();
381         change();
382     }
383     system("pause");
384 }

这是这次的代码很难想象，我以前没有编写过这么长的代码，感觉写完以后，非常感慨，这是在同伴缪湾湾同学的大力努力下，我们终于完成了这个程序。

首先是一个电梯的结构体，这是标志着电梯的参数，便于在电梯的调度中使用。

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;
};

这样就可以实现对电梯的调度。

接下来是对电梯参数的初始化，需要对电梯进行一些参数的赋值。

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 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;
}
}

这是实现电梯的超载设定。

然后还有进入电梯，出电梯，设定层数，更新电梯状态，判断是否到达相应楼层，判断使用哪部电梯的子函数等等，来实现这个电梯调度。在程序中已经标注，不再意义列举。

接下来进行电梯程序的演示。

这是第一个输入，输入所在的电梯层数和电梯方向。

然后电梯开始运行。

然后到达所在楼层。

然后还可以输入多个进入电梯。

我的结对编程队员是缪湾湾同学，她是一个非常认真的同学，在编程的时候一丝不苟，兢兢业业。在我们第一日的合作中，我们在一起讨论，在讨论完毕后，缪湾湾同学一口气编写了5个小时的程序，连中午饭都没有吃，她的认真态度感染着我，我是一个不是太能够专心的人，总是感觉坐不住，感觉整个人比较的飘，通过结对编程，我深深的明白了一个道理，那就是在编程这条道路上要想要走的更远，就必须坚实的坐下来，认认真真的编写程序，不能投机取巧，总是想着困难有多少，总是感觉不会做，到了工作之后，谁又能帮助你做这些事呢。同时，我的编程习惯不太严谨，这也是在和缪湾湾同学的合作中发现的一个巨大的问题，我觉的这个问题如果不加以改正，那么在以后的编写程序过程中，就很难于其他程序人员很好的合作，总之通过这次结对编程，我认识到了自己身上严重的不足，找到了自身与别人的差距，我不能在继续这样下去，希望以后还能像缪湾湾同学这样的高手请教，希望自己获的更大的提升。

在这次的编写过程中，我们经过了热烈的讨论，我写了前面的用户显示和显示函数，对于核心的调度函数，我们进行了激烈的讨论，由于算法的问题，我的算法存在一定的问题，在讨论的过程中，最终采用了缪湾湾同学的调度算法，再加上一定的更改，我们最后完成了我们的程序。

这个电梯基本的功能已经展示，但是还是有一些需要修改的地方。像电梯每次只能进一个人，这也许是我们的一个失误，我们觉的要是加以修改的话，可能需要我们的程序中添加循环，我们会在之后试一下我们的程序改进。另外，我们没有实现图形化显示，也有点遗憾。总之，我们以后如果有机会的话，我们一定会做的更好。同时，通过这次的结对编程，我和缪湾湾同学成为了更好的朋友，为以后的更好向她学习，建立了良好的友谊关系，希望以后还能多多请教。

队友的博客地址：

缪湾湾：博客链接：http://www.cnblogs.com/mww123/p/5370283.html

最后附上一张照片

希望以后能够有一些机会，继续像别人学习。

相关阅读:
Dirichlet Process 和 Dirichlet Process Mixture模型
 也说说EM
Seven Steps to Success Machine Learning in Practice
matlab norm 范式
 nginx中时间的管理
 Android中解析网络请求的URL
jsp if else c标签总结
 Android开发系列之button事件的4种写法
 oracle中split的使用
 Unix C++（boost）线程同步和线程组
原文地址：https://www.cnblogs.com/niuniu11/p/5370409.html

结对编程 电梯调度程序

结对编程电梯调度程序