C语言实现简单的电梯控制系统

    在刚刚看到这个题目的时候，觉得毫无头绪，之后在CSDN上面也看到了很多想法，但是大多不是C语言，也不是源码，或者编译不通过，可能是作为学生我用的编译器比较老了哈哈哈哈。不过也给了我一些启迪，以下是自己的一些想法，在DEV C++编译通过，个人觉得还可以参考哈哈哈，若有不足之处请不吝指正！

       下面就贴源码了，我也上传了资源，也可以去下面这个网址下载~

        https://download.csdn.net/download/qq_42073370/10603339

---

//
//elevator.h

/*****************************************************************************
/*C语言简易电梯实现(模拟状态机)
/*
/*通过定义两个枚举类型和两个结构表征电梯当前状态
/*
/*具有如下功能：
/*电梯状态初始化(电梯在一楼且电梯门关闭)
/*选择电梯是否继续运行
/*控制电梯每次运行时的方向
/*在电梯运行过程中添加层数
/*输入电梯层数是可乱序输入
/*判断电梯是否超载
/*增加或减少电梯内人数
/*宏定义电梯最大载客数和楼层范围,可根据需要修改elevator.c中的MAX_FLOOR,MAX_NUM
/*最后电梯还原为初始化时的状态 
******************************************************************************/

#ifndef elevator_h
#define elevator_h

//当前事件类型 
typedef enum tagT_EventType {
    EVENT_OPEN = 0,
    EVENT_UP,
    EVENT_DOWN,
    EVENT_CLOSE,
    EVENT_WARN,
    EVENT_STOP,
    EVENT_DELWARN
}T_EventType;

//当前状态类型
typedef enum tagT_StateType {
    STATE_STOP = 0,
    STATE_OPEN,
    STATE_UP,
    STATE_DOWN,
    STATE_WARN
}T_StateType;

//电梯状态结构参量 
typedef struct Elevator {
    int num;
    int level;
    T_EventType event;
    T_StateType state;
}El, *Ele;

//电梯需到达的楼层记录的结构
typedef struct Ele_floor {
    int floor;
    struct Ele_floor *next;
}Fl, *Flo;

//提示语
//事件列表 
void meau_event();
//状态列表 
void meau_state();
//楼层获取提示
void meau_floor(Ele p);

//电梯状态初始化(电梯处于一楼且电梯门关闭） 
void init_elevator(Ele p);

//楼层获取 
void Get_floor(Flo L, Ele p);

//删除已经到达的楼层
void Delete_floor(Flo L);

//电梯状态转换 
void trans_elevator(Ele p, int k);//k为接下来需要到达的楼层 

//遍历要到达的每个楼层 
void Every_floor(Flo s, Flo L, Ele p, int k);

//输出要到达的楼层
void Print_floor(Flo L);

//获取还要到达的楼层数目 
int Amount_floor(Flo L);

//将当前输入的楼层与一输入的楼层合并
Flo Merge_floor(Flo L1, Flo L2);

//删除重复楼层 
void Delete_samefloor(Flo L);

//楼层升序排序
void Sort_floorup(Flo L);

//楼层降序排列
void Sort_floordown(Flo L);

//逆置楼层 
void Reverse_floor(Flo L);

#endif/*elevator.h*/

---

//
//elevator.c 

#include <stdio.h>
#include <stdlib.h>
#include "elevator.h" 

#define MAX_FLOOR 10
#define MAX_NUM 10

//提示语
//事件列表 
void meau_event()
{
    printf(">> Event list:\n");
    printf(">> 1:EVENT_UP\n");
    printf(">> 2:EVENT_DOWN\n");
}
//状态列表 
void meau_state()
{
    printf("\n>> The floor range is: 1--MAX_NUM, and the floor input ends after -1!\n");
    printf(">> The elevator status represented by each number is:\n");
    printf(">> 0:STATE_STOP\n");
    printf(">> 1:STATE_OPEN\n");
    printf(">> 2:STATE_UP\n");
    printf(">> 3:STATE_DOWN\n");
    printf(">> 4:STATE_WARN\n");
}
//楼层获取提示
void meau_floor(Ele p)
{
    if (p->level == 1 && p->state != STATE_OPEN)
        printf(">> The elevator is on the ground floor now,please enter the floor you want to reach:", MAX_FLOOR);
    if (p->level == MAX_FLOOR && p->state != STATE_OPEN)
        printf(">> The elevator is on the top floor now,please enter the floor you want to reach:", MAX_FLOOR);
    if (p->level != 1 && p->level != MAX_FLOOR && p->state == STATE_UP)
        printf(">> The elevator is going up now,please enter the floor you want to reach:", MAX_FLOOR, p->level);
    if (p->level != 1 && p->level != MAX_FLOOR && p->state == STATE_DOWN)
        printf(">> The elevator is going down now,please enter the floor you want to reach:", MAX_FLOOR, p->level);
}

//电梯状态初始化(电梯处于一楼且电梯门关闭） 
void init_elevator(Ele p)
{
    p->num = 0;//电梯内人数为0 
    p->level = 1;//电梯处于一楼 
    p->state = (T_StateType)0;//电梯门处于关闭状态 
    if (p->state == STATE_STOP && p->level == 1)
        printf(">> Initializing the elevator successfully!\n");
}

//楼层获取 
void Get_floor(Flo L, Ele p)
{
    Fl *s, *r;
    int flag = 1;
    int x;
    r = L;
    meau_floor(p);
    while (flag) {
        if (p->level == 1) {//电梯处于底楼时 
            if (p->state == STATE_OPEN) break;
            scanf("%d", &x);
            if (x > 1 && x <= MAX_FLOOR) {
                s = (Flo)malloc(sizeof(Fl));
                s->floor = x;
                r->next = s;
                r = s;
            }
            else {
                flag = 0;
                r->next = NULL;
            }
        }
        if (p->level == MAX_FLOOR) {//电梯处于顶楼时
            if (p->state == STATE_OPEN) break;
            scanf("%d", &x);
            if (x >= 1 && x < MAX_FLOOR) {
                s = (Flo)malloc(sizeof(Fl));
                s->floor = x;
                r->next = s;
                r = s;
            }
            else {
                flag = 0;
                r->next = NULL;
            }
        }
        if (p->level != 1 && p->level != MAX_FLOOR && p->state == STATE_UP) {//电梯在一次运行中上升时 
            scanf("%d", &x);
            if (x > p->level && x <= MAX_FLOOR) {
                s = (Flo)malloc(sizeof(Fl));
                s->floor = x;
                r->next = s;
                r = s;
            }
            else {
                flag = 0;
                r->next = NULL;
            }
        }
        if (p->level != 1 && p->level != MAX_FLOOR && p->state == STATE_DOWN) {//电梯在一次运行中下降时 
            scanf("%d", &x);
            if (x < p->level && x >= 1) {
                s = (Flo)malloc(sizeof(Fl));
                s->floor = x;
                r->next = s;
                r = s;
            }
            else {
                flag = 0;
                r->next = NULL;
            }
        }
        if (p->level != 1 && p->level != MAX_FLOOR && p->state == STATE_OPEN) break;
    }
}

//电梯状态转换 
void trans_elevator(Ele p, int k)//k为接下来需要到达的楼层 
{
    switch (p->state) {
    case STATE_STOP:
        switch (p->event) {
        case EVENT_OPEN:
            p->state = (T_StateType)1;
            p->level = k;
            break;
        case EVENT_UP:
            p->state = (T_StateType)2;
            p->level = k;
            break;
        case EVENT_DOWN:
            p->state = (T_StateType)3;
            p->level = k;
            break;
        }
        break;
    case STATE_OPEN:
        switch (p->event) {
        case EVENT_CLOSE:
            p->state = (T_StateType)0;
            p->level = k;
            break;
        case EVENT_WARN:
            p->state = (T_StateType)4;
            p->level = k;
            break;
        }
        break;
    case STATE_UP:
        if (p->event == EVENT_STOP)
            p->state = (T_StateType)0;
        p->level = k;
        break;
    case STATE_DOWN:
        if (p->event == EVENT_STOP)
            p->state = (T_StateType)0;
        p->level = k;
        break;
    case STATE_WARN:
        if (p->event == EVENT_DELWARN)
            p->state = (T_StateType)1;
        p->level = k;
        break;
    }
}

//遍历要到达的每个楼层 
void Every_floor(Flo s, Flo L, Ele p, int k)
{
    while (s->next != NULL) {
        int w, flag;
        flag = 1;
        p->event = EVENT_STOP;
        trans_elevator(p, s->next->floor);
        p->event = EVENT_OPEN;
        trans_elevator(p, s->next->floor);
        printf("\n>> The elevator has reached the %d floor, the elevator is in the %d state,there are %d people in the elevator!\n", p->level, p->state, p->num);
        if (Amount_floor(s) > 1) {
            printf(">> If the number of people in the elevator increases, enter a positive number, otherwise enter a negative number:");
            while (flag) {
                scanf("%d", &w);
                if ((w + p->num) > MAX_NUM) {
                    p->event = EVENT_WARN;
                    trans_elevator(p, s->next->floor);
                    printf(">> Overweight, please re-enter:");
                }
                else {
                    p->event = EVENT_CLOSE;
                    trans_elevator(p, s->next->floor);
                    p->num = p->num + w;
                    flag = 0;
                }
            }
            if (p->state == STATE_STOP) printf(">> Elevator doors close,");
            if (k == 1) p->state = STATE_UP;
            else p->state = STATE_DOWN;
            printf("the elevator is in the state of %d, and there are %d people in the elevator\n", p->state, p->num);
        }
        Get_floor(L, p);
        Sort_floorup(L);
        Sort_floorup(s);
        Merge_floor(s, L);
        if (k == 2) Reverse_floor(s);
        Delete_samefloor(s);
        Delete_floor(s);
        if (s->next == NULL)
            printf(">> The elevator has reached all the right floors!\n");
        else {
            printf(">> The floors to be reached are:");
            Print_floor(s);
        }
    }
}

//删除已经到达的楼层
void Delete_floor(Flo L)
{
    Fl* temp;
    if (L->next != NULL) {
        temp = L->next;
        L->next = temp->next;
        free(temp);
    }
}

//输出要到达的所有楼层 
void Print_floor(Flo L)
{
    L = L->next;
    if (L == NULL)
        printf(">> NULL!");
    while (L != NULL) {
        printf("%d ", L->floor);
        L = L->next;
    }
    printf("\n");
}

//获取还要到达的楼层数目 
int Amount_floor(Flo L)
{
    Fl *p;
    int length = 0;
    p = L->next;
    while (p != NULL) {
        p = p->next;
        length++;
    }
    return length;
}

//将当前输入的楼层与已经输入的楼层合并 
Flo Merge_floor(Flo L1, Flo L2)
{
    Fl *p, *q, *r, *L3;
    p = L1->next;
    q = L2->next;
    r = L3 = L1;
    while (p&&q) {
        if (p->floor <= q->floor) {
            r->next = p;
            r = r->next;
            p = p->next;
        }
        else {
            r->next = q;
            r = r->next;
            q = q->next;
        }
    }
    if (p) r->next = p;
    if (q) r->next = q;
    free(L2);
    return L3;
}

//楼层升序排序
void Sort_floorup(Flo L)
{
    Flo p,q,r;
    r=L;
    while(r->next!=NULL){
        p=r;
        q=p->next;
        while(q->next!=NULL){
            if(p->next->floor>q->next->floor) p=q;
            q=q->next;
        }
        q=p->next;
        p->next=q->next;
        q->next=r->next;
        r->next=q;
        r=q;
    }
} 

//楼层降序排列
void Sort_floordown(Flo L)
{
    Sort_floorup(L);
    Reverse_floor(L);
}

//删除重复楼层 
void Delete_samefloor(Flo L)
{
    Fl *p, *q;
    p = L;
    q = L->next;
    while (q) {
        if (p->floor == q->floor) {
            q = q->next;
            p->next = q;
        }
        p = p->next;
        q = q->next;
    }
}

//逆置楼层顺序 
void Reverse_floor(Flo L)
{
    Fl *p, *s;
    p = L->next;
    L->next = NULL;
    while (p) {
        s = p;
        p = p->next;
        s->next = L->next;
        L->next = s;
    }
}

---

//
//main.c

#include <stdio.h>
#include <stdlib.h>
#include "elevator.h"

int main()
{
    El *p;//电梯状态 
    Fl *s, *L;//电梯需到达的层数(s存储开始时需要到达的层数，L存储电梯运行过程中需要增加的层数) 
    p = (El*)malloc(sizeof(El));
    s = (Fl*)malloc(sizeof(Fl));
    L = (Fl*)malloc(sizeof(Fl));
    s->next = NULL;
    L->next = NULL;

    //电梯初始化 
    init_elevator(p);

    //电梯运行 
    int ff, control;
    ff = 1;
    while (ff) {
        meau_state();
        printf("\n>> The elevator continues? If yes, please enter 1. If not, please enter 0:");
        scanf("%d", &control);
        if (control == 1) {
            int k;
            p->num = 0;
            printf(">> There are %d people in the elevator and the elevator is at %d building!\n", p->num, p->level);
            printf(">> Please enter the initial number of people on the elevator:");
            scanf("%d", &p->num);
            meau_event();
            printf(">> Please select the event:");
            scanf("%d", &k);
            if (k == 1) p->state = STATE_UP;
            else p->state = STATE_DOWN;
            Get_floor(s, p);//获取电梯要到达的楼层 
            if (k == 1) Sort_floorup(s);
            else Sort_floordown(s);
            printf(">> The floors to be reached are:");
            Print_floor(s);
            Every_floor(s, L, p, k);//遍历每个楼层 
        }
        else ff = 0;
        printf("\n>> Press any key to continue!");
        getch();
        system("cls");
    }
    //还原电梯
    init_elevator(p);

    //释放内存 
    free(p);
    free(s);
}

---