结对编程项目--电梯调度

      从本次开始，我们改变了作业模式，由起初的个人编程到结对编程的过渡，很好的让我们了解和认识别人的编程方法和习惯，同时也避开了以往个人编程中所遇到的诸多问题，让我想起了一句话，“一个人或许可以走的很快，但一定走的不远。”。

      接下来我们来回顾一下本次作业的内容及要求：

  电梯调度

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

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

      其使用规定如下：

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

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

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

     关于本次作业，刚看到的时候觉得各种问题好复杂，但是仔细分析之后思路便明了了，我和我的队友最终决定把问题条形化，分成一个个子问题逐一分析进而用一个个子函数来实现，这样复杂的问题就简单化了。当然这次的编程语言我们选了自我感觉最能解决也是我们比较熟悉的C++，感觉C语言好像不能完全实现诶>.<...

　　我和我的小伙伴首先简单分析了一下实现的过程。

　　一、电梯类，电梯类要能实现单双层的判断以及对所要去的电梯进行存储，最初我们打算默认让哪几个电梯跑单层，哪几个电梯跑双层，后来决定采用属性值来标识的做法，其次是电梯的存储，最开始我们用一个int型的数来存储目标楼层，但是测试过程中发现，如果只用一个int型变量的话，当电梯的目标楼层为多个或者需要中途改变的时候电梯会无法实现既定的目标，于是我提出用数组来直接存储多个目标，这样可以满足当多个用户使用电梯的需求。随之改变的是电梯的运行，以前的电梯运行只要判断当前楼层和目标楼层就可以做相应的执行，改变的电梯想要运行需要判断数组是否为空，当数组不为空时判断电梯的运行。电梯类中最难实现的方法应该是将目标楼层添加进数组了，因为情况很多，当时也没有分析明白，导致开发的进度一度毫无进展，经过伙伴的四方求助以及分析，我们最终将各种情况分化，化为一个一个小的情况，接下来的就简单多了，针对每一个小的情况，将目标楼层加入电梯的数组，接下来只要让电梯运行就可以。

　　

class Elevator{
private:
    int id;//电梯号
    int floor;//电梯当前楼层
    int max;//最大人数
    int Pnum;//当前人数
    int state;//0:全部 1：单层 2：双层
    int RunState;//0:不动  1：向上  2：向下
    int Queue[21];
    int start = 0, end = 0;
    int pState, toP;//pState 奇数时进人 偶数时出人
public:
    Elevator(int Enum, int floor, int Pnum, int state,int max);//构造函数
    int getId(){ return id; }//获取电梯号
    int getfloor(){ return floor; }//获取当前楼层数
    int getPnum(){ return Pnum; }//获取人数
    void Run();//电梯上下行
    void show();//显示函数
    void Add(int Pfloor, int Runstate, int tofloor, int Pnum);//根据方向添加进数组
    int countDistance(int pFloor, int runDirection);//计算电梯与人的距离
};
Elevator::Elevator(int id, int floor, int Pnum, int state,int max) :id(id), floor(floor), Pnum(Pnum),state(state),max(max){
    RunState = 0;
    pState = 1;
    toP = 0;
}
void Elevator::Run(){
    if (end != start)//需要电梯运行的情况
    {
        if (floor > Queue[start])//向下
        {
            RunState = 2;
            floor--;
            
        }
        if (floor < Queue[start])//向上
        {
            
            RunState = 1;
            floor++;
        }
        if (floor == Queue[start])//到达目的地
        {
            RunState = 0;
            start = (start++) % 21;//start指针向后移
            if (pState % 2 == 0){//出人
                if (start == end)
                    Pnum = 0;
                else
                    Pnum = Pnum - abs(rand() % Pnum);
                pState++;
            }
            else{//进人
                Pnum += toP;
                if (Pnum > max)
                {
                    cout << "超重了，需要下" << Pnum - max << "人";
                    Pnum = max;
                }
                pState++;
            }
        }
    }
    else{
        RunState = 0;
    }
    
}
void Elevator::Add(int Pfloor, int runDirection, int tofloor,int person){
    toP = person;
    if (end - start < 1)//end指向下一个地址
    {
        Queue[(end++) % 21] = Pfloor;
        Queue[(end++) % 21] = tofloor;
        
    }
    else
    {
        if (runDirection == 1)//人向上
        {
            if (Queue[end - 1]>Queue[end - 2])//电梯向上
            {
                if (Queue[end - 1] > Pfloor)//电梯的目标楼层大于人当前的楼层
                {
                    Queue[end] = Queue[end - 1];
                    Queue[end - 1] = Pfloor;
                    end = (end++) % 21;
                }
                else//小于
                {
                    Queue[end] = Pfloor;
                    end = (end++) % 21;
                }
                if (Queue[end - 1] > tofloor)//队列中的最后一个数大于人的目标楼层时
                {
                    Queue[end] = Queue[end - 1];
                    Queue[end - 1] = tofloor;
                    end = (end++) % 21;
                }
                else
                {
                    Queue[end] = tofloor;
                    end = (end++) % 21;
                }
            }
            if (Queue[end - 1]<Queue[end - 2])//电梯向下
            {
                if (Queue[end - 1] > Pfloor)//电梯的目标楼层大于人当前的楼层
                {
                    Queue[end] = Pfloor;
                    end = (end++) % 21;
                    Queue[end] = tofloor;
                    end = (end++) % 21;
                }
            }
        }
        if (runDirection == 2)//人向下
        {
            if (Queue[end - 1]>Queue[end - 2])//电梯向上
            {
                if (Queue[end - 1] < Pfloor)//电梯的目标楼层小于人当前的楼层
                {
                    Queue[end] = Pfloor;
                    end = (end++) % 21;
                    Queue[end] = tofloor;
                    end = (end++) % 21;
                }
            }
            else//电梯向下
            {
                if (Queue[end - 1]<Pfloor)//电梯的目标楼层小于人当前的楼层
                {
                    Queue[end] = Queue[end - 1];
                    Queue[end - 1] = Pfloor;
                    end = (end++) % 21;
                }
                else
                {
                    Queue[end] = Pfloor;
                    end = (end++) % 21;
                }
                if (Queue[end - 1] < tofloor)//队列中的最后一个数小于人的目标楼层时
                {
                    Queue[end] = Queue[end - 1];
                    Queue[end - 1] = tofloor;
                    end = (end++) % 21;
                }
                else
                {
                    Queue[end] = tofloor;
                    end = (end++) % 21;
                }
            }
        }
    }
}
void Elevator::show(){
    cout << "id:" << id;
    cout << "电梯,在" << floor << "楼";
    cout << " 运行方向:";
    if (0 == RunState)//不动
    {
        cout << "  -";
    }
    if (1 == RunState)//向上
    {
        cout << "  ↑";
    }
    if (2 == RunState)//向下
    {
        cout << "  ↓";
    }
    cout << "人：" << Pnum << endl;
    cout << endl;
}
int Elevator::countDistance(int pFloor, int runDirection){
    if (state == 1&&pFloor%2==0)//电梯单层 人在双层
    {
        return 100;
    }
    if (state==2&&pFloor%2!=0)//电梯双层 人在单层
    {
        return 100;
    }
    if (end == start)//电梯静止时
    {
        return abs(floor-pFloor);
    }
    if (end - start == 1)//电梯只有一个目标楼层时
    {
        if (floor<Queue[start])//电梯上行
        {
            if (runDirection == 1)//人上行
            {
                if (pFloor<floor)//人在当前楼层下方
                {
                    return (2 * (Queue[start] - floor) + (floor - pFloor));
                }
                if (pFloor>=floor)//人在当前楼层上方
                {
                    return (pFloor - floor);
                }
            }
            if (runDirection == 2)//人下行
            {
                if (pFloor<floor)//人在当前楼层下方
                {
                    return (2 * (Queue[start] - floor) + (floor - pFloor));
                }
                if (pFloor >Queue[start])//人在当前楼层上方
                {
                    return (pFloor - floor);
                }
                if (pFloor >= floor&&pFloor <= Queue[start])//人在当前楼层和目标楼层之间
                {
                    return (Queue[start] - floor + Queue[start] - pFloor);
                }
            }
        }
        else//电梯下行
        {
            if (runDirection == 1)//人上行
            {
                if (pFloor < floor)//人在当前楼层下方
                {
                    return (floor-Queue[start]+pFloor-Queue[start]);
                }
                if (pFloor >= floor)//人在当前楼层上方
                {
                    return (2*(floor-Queue[start])+pFloor-floor);
                }
                if (pFloor >= floor&&pFloor <= Queue[start])//人在当前楼层和目标楼层之间
                {
                    return (floor-Queue[start]+pFloor-Queue[start]);
                }
            }
            if (runDirection == 2)//人下行
            {
                if (pFloor<floor)//人在当前楼层下方
                {
                    return (floor-pFloor);
                }
                if (pFloor >Queue[start])//人在当前楼层上方
                {
                    return (2*(floor-Queue[start])+pFloor-floor);
                }
            }
        }
    }
    if (end-start>1)//电梯有两个或两个以上目标楼层时
    {
        if (Queue[end-2]<Queue[end-1])//电梯上行
        {
            if (runDirection == 1)//人上行
            {
                if (pFloor>=Queue[end-2])//人在目标楼层1上方
                {
                    return (pFloor-Queue[end-2]);
                }
                if (pFloor<Queue[end-2])//人在目标楼层1下方
                {
                    return (2*(Queue[end-1]-Queue[end-2])+Queue[end-2]-pFloor);
                }
            }
                if (runDirection == 2)//人下行
                {
                    if (pFloor<Queue[end - 2])//人在目标楼层1下方
                    {
                        return (2 * (Queue[end - 1] - Queue[end - 2]) + (Queue[end - 2] - pFloor));
                    }
                    if (pFloor >Queue[end - 1])//人在目标楼层2上方
                    {
                        return (pFloor - Queue[end - 2]);
                    }
                    if (pFloor >= Queue[end - 2] && pFloor <= Queue[end - 1])//人在目标楼层1和目标楼层2之间
                    {
                        return (Queue[end - 1] - Queue[end - 2] + Queue[end - 1] - pFloor);
                    }
                }
        }
        else//电梯下行
        {
            if (runDirection == 1)//人上行
            {
                if (pFloor<Queue[end-1])//人在目标楼层2下方
                {
                    return (Queue[end-2]-pFloor);
                }
                if (pFloor>Queue[end-2])//人在目标楼层1上方
                {
                    return (2*(Queue[end-2]-Queue[end-1])+pFloor-Queue[end-2]);
                }
                if (pFloor>=Queue[end-1]&&pFloor<=Queue[end-2])//人在目标楼层1和2之间
                {
                    return (Queue[end-2]-Queue[end-1]+pFloor-Queue[end-1]);
                }
            }
            if (runDirection == 2)//人下行
            {
                if (pFloor>Queue[end-2])//人在目标楼层1上方
                {
                    return (2*(Queue[end-2]-Queue[end-1])+pFloor-Queue[end-2]);
                }
                if (pFloor<=Queue[end-2])//人在目标楼层1下方
                {
                    return (Queue[end - 2] - pFloor);
                }
            }
        }    
    }
}

　　电梯类中主要有id 电梯号 floor 电梯当前楼层 Pnum当前人数等属性，方法有add方法，run方法 show方法以及countDistance方法

　　二、电梯的运行，起初我们以为电梯的运行是一件很简单的事情，只要让它上上下下就可以，但后来我发现的我们大错特错了，电梯本身的运行很简单，但是当电梯的数目增加时，电梯的运行变得很难实现，首先是如何判断多个电梯中的哪个电梯去响应对应楼层的按钮，其次是判断后怎么让相应的电梯去到按钮所在的楼层，响应按钮后如何将人所在的楼层和人要去的楼层合理的添加进数组的相应位置，在这里我们给电梯类添加了一个新的方法，通过判断电梯与人之间所隔的楼层数来判断哪个电梯去响应按钮，最后是电梯的状态判断，在电梯的run方法中，当电梯的运行状态改变时，更改电梯当前的运动状态。

//    cout << e1.countDistance(pFloor, runDirection);
    //    cout << e2.countDistance(pFloor, runDirection);
    //    cout << e3.countDistance(pFloor, runDirection);
    //    cout << e4.countDistance(pFloor, runDirection);
        //电梯最优解
        int num;
        num = compareDistance(e1.countDistance(pFloor, runDirection), e2.countDistance(pFloor, runDirection), e3.countDistance(pFloor, runDirection), e4.countDistance(pFloor, runDirection));
        if (num==1)//e1最近
        {
            e1.Add(pFloor, runDirection, toFloor,person);
        }
        if (num==2)//e2最近
        {
            e2.Add(pFloor, runDirection, toFloor, person);
        }
        if (num==3)//e3最近
        {
            e3.Add(pFloor, runDirection, toFloor, person);
        }
        if (num==4)//e4最近
        {
            e4.Add(pFloor, runDirection, toFloor, person);
        }

　　三、人数的判断，最初的电梯人数的限制很简单，因为电梯目标只有一个，所以只要判断响应按钮时进入的人少于最大人数就可以，更改后的电梯则不行，因为存在电梯有多个目标中途下人的情况，所以我们又为电梯添加了两个新的属性，用以判断电梯是应该上人还是应该下人，以及电梯上人的时候有多少人，下人时则采取随机数方式。人数的增减则增加在电梯的运行方法中，并且改变时予以判断，如果应该下人是否为目标楼层，是的话将人数清零；如果上人超限的话则输出应下电梯多少人，以及将电梯人数设置成最大值（依据现实情况）。

void Elevator::Run(){
    if (end != start)//需要电梯运行的情况
    {
        if (floor > Queue[start])//向下
        {
            RunState = 2;
            floor--;
            
        }
        if (floor < Queue[start])//向上
        {
            
            RunState = 1;
            floor++;
        }
        if (floor == Queue[start])//到达目的地
        {
            RunState = 0;
            start = (start++) % 21;//start指针向后移
            if (pState % 2 == 0){//出人
                if (start == end)
                    Pnum = 0;
                else
                    Pnum = Pnum - abs(rand() % Pnum);
                pState++;
            }
            else{//进人
                Pnum += toP;
                if (Pnum > max)
                {
                    cout << "超重了，需要下" << Pnum - max << "人";
                    Pnum = max;
                }
                pState++;
            }
        }
    }
    else{
        RunState = 0;
    }
    
}

　　四、数据的输入，由于设计的不断改变，输入的数据也不断变化，因为界面的不到位，这里采用纯手工输入的方式，输入人所在的楼层，按的按钮的方向，人要去的楼层以及要上电梯的人数。由于采用循环的方式，应该有输入数据无效的情况，这时应让电梯自行运行。

 int Pnum, pFloor, toFloor, runDirection ,person,t=0;//  pFloor:人当前所在楼层  toFloor：人的目标楼层 runDirection:1向上 2向下  person:进电梯的人数
    cout << "请输入指令，
格式为： 人所在楼层  按钮方向 人的目标楼层  人数"<<endl;
    while (true)
    {
        cin >> pFloor >> runDirection >> toFloor>>person;
        if (pFloor == -1)
        {
            //无效操作
            e1.show();
            e2.show();
            e3.show();
            e4.show();
            e1.Run();
            e2.Run();
            e3.Run();
            e4.Run();
            continue;
        }

　　五、界面的实现，电梯类的实现耗费了多天的时间，本来兴致满满的打算写一个界面，然而当我们去实现时，才发现时间所剩不多，现学现做一个图形化界面已经来不及，所以草草的写了个输出函数，在控制台中输出电梯的运行情况

　　

void Elevator::show(){
    cout << "id:" << id;
    cout << "电梯,在" << floor << "楼";
    cout << " 运行方向:";
    if (0 == RunState)//不动
    {
        cout << "  -";
    }
    if (1 == RunState)//向上
    {
        cout << "  ↑";
    }
    if (2 == RunState)//向下
    {
        cout << "  ↓";
    }
    cout << "人：" << Pnum << endl;
    cout << endl;
}

     六、代码运行结果如下：

　　

总结：

       结对编程对于我们来讲，是一次全新的编程作业模式，作业过程中有与队友思想的冲突，也有共同改进完善的欣喜，一点点的进步直到整个编程作业的完成，让我体验到了结对编程的益处，也使自己的编程习惯得到了很大的改善和提高。另外，逐步分析使问题化繁为简也是我们这次编程作业的关键点，拿到一个问题，刚开始也许会一头雾水，但是把一个复杂的问题拆分为若干个子问题，这样整个思路就十分清晰了，希望自己以后对待任何问题也能如此解决，沉着冷静。

工作照: