餐馆排队叫号系统（Qt）

这是前一段时间专业课的一个作业，是新手用Qt写的第一个程序，里面很多按键设置都是直接用代码实现的

自己感觉新手写的代码可能让初步学习Qt的人看地更明白，所以打算在这篇文章中贴出程序，希望有帮助（代码仍有很多不足，请多多包涵）

题目：三种桌子（10—8、8—5、4及以下），自己输入每种桌子的个数以及客人来和走的所用的时间

程序主要部分就两个：队列和定时器，，其中定时器起的作用更多

难以理解的部分为：

 connect(max_table[i][j].time_table,&QTimer::timeout,this,
                    [i,j,this](){max_table[i][j].make_sure=0;
                        now_max_table_num_++;
                        max_table[i][j].time_table->stop();
                        PutTable();
                    });

//RestaurantQueue.pro
QT       += core gui
QT       += core testlib
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17
DEFINES += QT_DEPRECATED_WARNINGS
# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    main.cpp \
    restaurantqueue.cpp

HEADERS += \
    restaurantqueue.h

FORMS += \
    restaurantqueue.ui

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

RESOURCES += \
    image.qrc

QT.testlib.CONFIG -= console

//RestaurantQueue.h
#ifndef RESTAURANTQUEUE_H
#define RESTAURANTQUEUE_H

#include <QWidget>
#include <QTime>
#include <QObject>
#include<QRandomGenerator>
#include <QTimer>
#include <QTableWidget>
#include <QRegularExpression>
#include <QStackedWidget>
#include <QMessageBox>
#include <QTest>
#include <iostream>
using namespace std;

QT_BEGIN_NAMESPACE
namespace Ui { class RestaurantQueue; }
QT_END_NAMESPACE

struct Table{
    int make_sure=0; //判断桌子状态
    QTimer* time_table; //定时器
};

struct Customer {
    int customer_num;
    int order; //号
    Customer* next;
};

class RestaurantQueue : public QWidget
{
    Q_OBJECT

public:
    RestaurantQueue(QWidget *parent = nullptr);
    ~RestaurantQueue();
public slots:
    void SituationQuenue(); //三个列表
    void Delay(int delay_time); //延时
    void Start(); //开始
    void Play(int num,Table all_table[6][6]);
    void Pause(int num,Table all_table[6][6]);
    void PauseOrPlay(); //暂停或继续
    void SpeedUp(int value); //加速动画
    void Clear(); //清除
    void Close(); //关闭/退出
    void PutTable(); //放桌子
    void QueueCause(); //排队的状态
    void LineUp(); //排队
    void ChangeTime(); //改变定时器
    void LeaveLine(); //离开队伍
    void CallOrder(); //叫号屏并延时
    void Warn(); //警告
private:
    Ui::RestaurantQueue *ui;
    QTimer*count_time_1; //计时（客人）
    Table max_table[6][6];
    Table mid_table[6][6];
    Table min_table[6][6];
    int max_table_num_; //10-8人桌
    int mid_table_num_; //8-5人桌
    int min_table_num_; //4人及一下的桌子
    int now_max_table_num_;
    int now_mid_table_num_;
    int now_min_table_num_;
    int customer_num_; //一次来的客人的数量
    int put_row_; //排队的人数
    int give_order_; //给顾客的序号
    int call_order_; //叫的号
    int speed_; //动画演示的速度
    int use_time_; //一桌客人用餐的时间
    int come_time_; //客人来的时间间隔
    int pause_; //判断是否暂停
    int clear_; //判断是否清除
    int warn_style_; //警告的类型
    Customer* max_front, * max_rear;
    Customer* mid_front, * mid_rear;
    Customer* min_front, * min_rear;
};

#endif // RESTAURANTQUEUE_H

//RestaurantQueue.cpp
#include "restaurantqueue.h"
#include "ui_restaurantqueue.h"

RestaurantQueue::RestaurantQueue(QWidget *parent) //构造函数
    : QWidget(parent)
    , ui(new Ui::RestaurantQueue)
{
    ui->setupUi(this);
    this->setWindowIcon(QIcon(QPixmap(":/photo/queue.png")));
    //初始化
    put_row_=0; //排队人数
    give_order_=0;
    call_order_=0;
    speed_=1;
    pause_=0;
    clear_=0;
    QPixmap *pixmap = new QPixmap(":/photo/call_table.png"); //叫号台
    pixmap->scaled(ui->label_6->size(), Qt::KeepAspectRatio);
    ui->label_6->setScaledContents(true);
    ui->label_6->setPixmap(*pixmap);


    ui->lineEdit_1->setAlignment(Qt::AlignHCenter);
    ui->lineEdit_2->setAlignment(Qt::AlignHCenter);
    ui->lineEdit_3->setAlignment(Qt::AlignHCenter);
    ui->lineEdit_4->setAlignment(Qt::AlignHCenter);
    ui->lineEdit_5->setAlignment(Qt::AlignHCenter);
    ui->lineEdit_6->setAlignment(Qt::AlignHCenter); //对齐方式 居中
    ui->pushButton_1->setEnabled(1); //开始可点击
    ui->pushButton_3->setEnabled(0); //清除不可点击
    ui->pushButton_4->setEnabled(1); //退出可点击
    ui->pushButton_2->setEnabled(0); //暂停/继续不可点击
    ui->pushButton_2->setIcon(QIcon(":/photo/play.png"));
    ui->pushButton_3->setIcon(QIcon(":/photo/clear.png"));
    ui->pushButton_4->setIcon(QIcon(":/photo/leave.png"));
    ui->horizontalSlider->setEnabled(1);
    ui->horizontalSlider->setRange(1,7);
    ui->horizontalSlider->setSingleStep(2);
    ui->horizontalSlider->setPageStep(1);
    this->setWindowTitle("餐馆排队叫号系统模拟");
    this->setWindowFlags(Qt::CustomizeWindowHint|Qt::WindowMinimizeButtonHint|Qt::WindowMaximizeButtonHint|Qt::WindowCloseButtonHint);
    ui->tableWidget_1->setSelectionMode(QAbstractItemView::NoSelection);
    ui->tableWidget_2->setSelectionMode(QAbstractItemView::NoSelection);
    ui->tableWidget_3->setSelectionMode(QAbstractItemView::NoSelection);
    ui->tableWidget_4->setSelectionMode(QAbstractItemView::NoSelection);
    ui->tableWidget_5->setSelectionMode(QAbstractItemView::NoSelection); //不可选择
    ui->tableWidget_6->setSelectionMode(QAbstractItemView::NoSelection);
    ui->tableWidget_7->setSelectionMode(QAbstractItemView::NoSelection);
    ui->tableWidget_1->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget_2->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget_3->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget_4->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget_5->setEditTriggers(QAbstractItemView::NoEditTriggers);//不可修改
    ui->tableWidget_6->setEditTriggers(QAbstractItemView::NoEditTriggers);
    ui->tableWidget_7->setEditTriggers(QAbstractItemView::NoEditTriggers);
    QStringList header; //表头
    header<<"序号"<<"人数";
    ui->tableWidget_1->horizontalHeader()->setDefaultSectionSize(80);
    ui->tableWidget_2->horizontalHeader()->setDefaultSectionSize(80);
    ui->tableWidget_3->horizontalHeader()->setDefaultSectionSize(80);
    ui->tableWidget_1->setColumnCount(2);
    ui->tableWidget_2->setColumnCount(2);
    ui->tableWidget_3->setColumnCount(2);
    ui->tableWidget_1->setRowCount(20);
    ui->tableWidget_2->setRowCount(20);
    ui->tableWidget_3->setRowCount(20);
    ui->tableWidget_4->setColumnCount(1);
    ui->tableWidget_4->setRowCount(30);
    ui->tableWidget_4->verticalHeader()->setHidden(1);
    ui->tableWidget_4->horizontalHeader()->setHidden(1);
    ui->tableWidget_5->verticalHeader()->setHidden(1);
    ui->tableWidget_5->horizontalHeader()->setHidden(1);
    ui->tableWidget_6->verticalHeader()->setHidden(1);
    ui->tableWidget_6->horizontalHeader()->setHidden(1);
    ui->tableWidget_7->verticalHeader()->setHidden(1);
    ui->tableWidget_7->horizontalHeader()->setHidden(1);
    ui->tableWidget_1->setHorizontalHeaderLabels(header);
    ui->tableWidget_2->setHorizontalHeaderLabels(header);
    ui->tableWidget_3->setHorizontalHeaderLabels(header);
    Customer*max_first=new Customer;
    max_first->next=nullptr;
    this->max_front=this->max_rear=max_first;
    Customer*mid_first=new Customer;
    mid_first->next=nullptr;
    this->mid_front=this->mid_rear=mid_first;
    Customer*min_first=new Customer;
    min_first->next=nullptr;
    this->min_front=this->min_rear=min_first;

    connect(ui->pushButton_1,SIGNAL(clicked()),this,SLOT(Start()));
    connect(ui->pushButton_2,SIGNAL(clicked()),this,SLOT(PauseOrPlay()));
    connect(ui->pushButton_3,SIGNAL(clicked()),this,SLOT(Clear()));
    connect(ui->pushButton_4,SIGNAL(clicked()),this,SLOT(Close()));
    connect(ui->horizontalSlider,&QSlider::valueChanged,this,&RestaurantQueue::SpeedUp);
    connect(ui->horizontalSlider,SIGNAL(clicked()),this,SLOT(ChangeTime()));
}

RestaurantQueue::~RestaurantQueue()
{
    delete ui;
}

void RestaurantQueue::Delay(int delay_time) //延时函数
{
    QTime die_time=QTime::currentTime().addMSecs(delay_time);
    while(QTime::currentTime()<die_time)
    {
         QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
        if(clear_==1||pause_==1)
             return;
    }
}

void RestaurantQueue::Start() //开始键
{
    Warn(); //警告判断
    if(warn_style_!=0)
        return;
    put_row_=0;
    pause_=0;
    clear_=0;
    call_order_=0;
    ui->pushButton_1->setEnabled(0);//开始不可点击
    ui->horizontalSlider->setEnabled(0);
    ui->pushButton_3->setEnabled(1);
    ui->pushButton_2->setIcon(QIcon(":/photo/play.png"));
    ui->pushButton_2->setEnabled(1);
    ui->lineEdit_1->setEnabled(0);
    ui->lineEdit_2->setEnabled(0);
    ui->lineEdit_3->setEnabled(0);
    ui->lineEdit_4->setEnabled(0);
    ui->lineEdit_5->setEnabled(0);
    max_table_num_=ui->lineEdit_1->text().toDouble();
    mid_table_num_=ui->lineEdit_2->text().toDouble();
    min_table_num_=ui->lineEdit_3->text().toDouble();
    now_max_table_num_=max_table_num_;
    now_mid_table_num_=mid_table_num_;
    now_min_table_num_=min_table_num_;
    come_time_=ui->lineEdit_4->text().toDouble();
    use_time_=ui->lineEdit_5->text().toDouble();
    for(int i=0;i<6;i++) //初始化
    {
        for(int j=0;j<6;j++)
        {
            max_table[i][j].time_table=new QTimer();
            max_table[i][j].time_table->setInterval(use_time_*60*1000/(speed_*20));
            connect(max_table[i][j].time_table,&QTimer::timeout,this,
                    [i,j,this](){max_table[i][j].make_sure=0;

                        now_max_table_num_++;
                        max_table[i][j].time_table->stop();
                        PutTable();
                    });
            mid_table[i][j].time_table=new QTimer();
            mid_table[i][j].time_table->setInterval(use_time_*60*1000/(speed_*20));
            connect(mid_table[i][j].time_table,&QTimer::timeout,this,
                    [i,j,this](){mid_table[i][j].make_sure=0;

                        now_mid_table_num_++;
                        mid_table[i][j].time_table->stop();
                        PutTable();
                    });
            min_table[i][j].time_table=new QTimer();
            min_table[i][j].time_table->setInterval(use_time_*60*1000/(speed_*20));
            connect(min_table[i][j].time_table,&QTimer::timeout,this,
                    [i,j,this](){min_table[i][j].make_sure=0;

                        now_min_table_num_++;
                        min_table[i][j].time_table->stop();
                        PutTable();
                    });
        }
    }
    PutTable(); //摆放桌子
    count_time_1=new QTimer(); //决定客人到来的定时器
    count_time_1->setInterval(come_time_*60*1000/(speed_*20));
    connect(count_time_1,&QTimer::timeout,this,&RestaurantQueue::LineUp);
    count_time_1->start();
}

void RestaurantQueue::LineUp() //排队
{

    int how_table=0; //类型
    customer_num_=QRandomGenerator::global()->bounded(1, 11);
    if(put_row_>30)//当排队人数大于30时且对应无桌子时，不再接客
    {
        if(customer_num_<=10&&customer_num_>8&&now_max_table_num_==0)
             return;
        if(customer_num_==8&&max_table_num_==0&&now_mid_table_num_==0&&now_max_table_num_==0)
             return;
        if(customer_num_<8&&customer_num_>4&&now_mid_table_num_==0)
             return;
        if(customer_num_<=4&&now_min_table_num_==0)
             return;
    }
    if(customer_num_<=10&&customer_num_>8) how_table=1; //类型分配
    if(customer_num_==8) how_table=2;
    if(customer_num_<8&&customer_num_>4) how_table=3;
    if(customer_num_<=4) how_table=4;
    give_order_++;
    //qDebug()<<customer_num_;
    switch (how_table) { //根据类型，加到不同的队列中
    case 1:{
            Customer*node=new Customer;
            node->order=give_order_;
            node->customer_num=customer_num_;
            //qDebug()<<node->customer_num;
            node->next=max_rear->next;
            max_rear->next=node;
            max_rear=node;
            break;
           }
    case 2:{
            if(now_max_table_num_==0&&now_mid_table_num_!=0)
            {
               Customer*node=new Customer;
               node->order=give_order_;
               node->customer_num=customer_num_;
               node->next=mid_rear->next;
               mid_rear->next=node;
               mid_rear=node;
            }
            else
            {
               Customer*node=new Customer;
               node->order=give_order_;
               node->customer_num=customer_num_;
               node->next=max_rear->next;
               max_rear->next=node;
               max_rear=node;
            }
            break;
            }


    case 3:{
            Customer*node=new Customer;
            node->order=give_order_;
            node->customer_num=customer_num_;
           // qDebug()<<node->customer_num;
            node->next=mid_rear->next;
            mid_rear->next=node;
            mid_rear=node;
            break;
            }
    case 4:{
            Customer*node=new Customer;
            node->order=give_order_;
            node->customer_num=customer_num_;
            node->next=min_rear->next;
            min_rear->next=node;
            min_rear=node;
            break;
    }
    }
    put_row_++;
   // qDebug()<<put_row_;
    QueueCause(); //更新
    LeaveLine();

}

void RestaurantQueue::CallOrder() //叫号屏显示
{
    ui->lineEdit_6->setText(QString::number(call_order_));
    Delay(500/speed_);
}

void RestaurantQueue::LeaveLine() //去就餐
{
    CallOrder();
    int num=0;//遍历过的桌子的数量
    int max_row_line_num=1;
    int mid_row_line_num=1;
    int min_row_line_num=1;
    while(max_row_line_num*max_row_line_num<max_table_num_)
    {
        max_row_line_num++;
    }
    while(mid_row_line_num*mid_row_line_num<mid_table_num_)
    {
        mid_row_line_num++;
    }
    while(min_row_line_num*min_row_line_num<min_table_num_)
    {
        min_row_line_num++;
    }

    for(int i=0;i<max_row_line_num;i++) //删除结点
    {
        for(int j=0;j<max_row_line_num;j++)
        {
             num++;
             Customer*node=max_front->next;
             if(node==nullptr)
             {
                 max_rear=max_front;
                 j=max_row_line_num;
                 i=max_row_line_num;
             }
             if(max_table[i][j].make_sure==0&&node!=nullptr&&num<=max_table_num_)
             {
                 max_table[i][j].time_table->start(); //开启餐桌的定时器
                 max_table[i][j].make_sure=1;
                 now_max_table_num_--;
                 put_row_--;
                 call_order_=node->order;
                 CallOrder();
                 max_front->next=node->next;
                 delete node;
                 QueueCause();
                 PutTable();
             }
        }
    }
    num=0;
    for(int i=0;i<mid_row_line_num;i++)
    {
        for(int j=0;j<mid_row_line_num;j++)
        {
             num++;
             Customer*node=mid_front->next;
             if(node==nullptr)
             {
                 mid_rear=mid_front;
                 j=mid_row_line_num;
                 i=mid_row_line_num;
             }
             if(mid_table[i][j].make_sure==0&&node!=nullptr&&num<=mid_table_num_)
             {
                 mid_table[i][j].time_table->start();
                 mid_table[i][j].make_sure=1;
                 now_mid_table_num_--;
                 put_row_--;
                 call_order_=node->order;
                 CallOrder();
                 mid_front->next=node->next;
                 delete node;
                 QueueCause();
                 PutTable();
                 //table_widget->setItem(i,j, new QTableWidgetItem(QIcon(":/photo/not_use.png"), " "));
             }
        }
    }
    num=0;
    for(int i=0;i<min_row_line_num;i++)
    {
        for(int j=0;j<min_row_line_num;j++)
        {
             num++;
             Customer*node=min_front->next;
             if(node==nullptr)
             {
                 min_rear=min_front;
                 j=min_row_line_num;
                 i=min_row_line_num;
             }
             if(min_table[i][j].make_sure==0&&node!=nullptr&&num<=min_table_num_)
             {
                 min_table[i][j].time_table->start();
                 min_table[i][j].make_sure=1;
                 now_min_table_num_--;
                 put_row_--;
                 call_order_=node->order;
                 CallOrder();
                 min_front->next=node->next;
                 delete node;
                 QueueCause();
                 PutTable();
             }
        }
    }
}

void RestaurantQueue::Clear() //清除
{
    clear_=1;
    put_row_=0;
    give_order_=0;
    call_order_=0;
    for(int i=0;i<6;i++)
    {
        for(int j=0;j<6;j++) //餐桌属性，空闲
        {
             max_table[i][j].make_sure=0;
             mid_table[i][j].make_sure=0;
             min_table[i][j].make_sure=0;
        }
    }
    for(int i=0;i<6;i++)
    {
        for(int j=0;j<6;j++) //删除定时器
        {
             delete max_table[i][j].time_table;
             delete mid_table[i][j].time_table;
             delete min_table[i][j].time_table;
        }
    }
    ui->lineEdit_1->setEnabled(1);
    ui->lineEdit_2->setEnabled(1);
    ui->lineEdit_3->setEnabled(1);
    ui->lineEdit_4->setEnabled(1);
    ui->lineEdit_5->setEnabled(1);
    ui->pushButton_1->setEnabled(1); //开始可点击
    ui->pushButton_2->setEnabled(0);
    ui->horizontalSlider->setEnabled(1);
    ui->pushButton_2->setIcon(QIcon(":/photo/play.png"));
    ui->lineEdit_6->clear();
    ui->tableWidget_1->clearContents();
    ui->tableWidget_2->clearContents();
    ui->tableWidget_3->clearContents();
    ui->tableWidget_4->clearContents();
    ui->tableWidget_5->clearContents(); //清除表格内的内容
    ui->tableWidget_6->clearContents();
    ui->tableWidget_7->clearContents();

    while(max_front->next!=nullptr) //清除各队列
    {
        Customer*max_node=max_front->next;
        max_front->next=max_node->next;
        max_rear=max_front;
        delete max_node;
    }
    while(mid_front->next!=nullptr)
    {
        Customer*mid_node=mid_front->next;
        mid_front->next=mid_node->next;
        mid_rear=mid_front;
        delete mid_node;
    }
    while(min_front->next!=nullptr)
    {
        Customer*min_node=min_front->next;
        min_front->next=min_node->next;
        min_rear=min_front;
        delete min_node;
    }
    delete count_time_1; //删除客人的定时器
}

void RestaurantQueue::QueueCause() //显示排队
{
    int num=0;
    Customer*max_node=max_front->next;
    Customer*mid_node=mid_front->next;
    Customer*min_node=min_front->next;
    ui->tableWidget_4->clearContents();
    while(max_node!=nullptr) //依次显示大桌子、中桌子、小桌子排队的人，遍历各队列
    {
        ui->tableWidget_4->setItem(num,0, new QTableWidgetItem(QString::number(max_node->order)));
        num++;
        max_node=max_node->next;

    }
    while(mid_node!=nullptr)
    {
        ui->tableWidget_4->setItem(num,0, new QTableWidgetItem(QString::number(mid_node->order)));
        num++;
        mid_node=mid_node->next;
    }
    while(min_node!=nullptr)
    {
        ui->tableWidget_4->setItem(num,0, new QTableWidgetItem(QString::number(min_node->order)));
        num++;
        min_node=min_node->next;
    }
    SituationQuenue(); //更新ui
    Delay(500/speed_);
}

void RestaurantQueue::SituationQuenue() //表格展示排队状况
{
    int max,mid,min;
    max=0;mid=0;min=0;
    Customer*max_node=max_front->next;
    Customer*mid_node=mid_front->next;
    Customer*min_node=min_front->next;
    ui->tableWidget_1->clearContents();
    ui->tableWidget_2->clearContents();
    ui->tableWidget_3->clearContents();
    while(max_node!=nullptr) //遍历，在表格中显示数据
    {
        ui->tableWidget_1->setItem(max,0, new QTableWidgetItem(QString::number(max_node->order)));
        ui->tableWidget_1->setItem(max,1, new QTableWidgetItem(QString::number(max_node->customer_num)));
        //qDebug()<<max_node->order;
        max_node=max_node->next;
        max++;
    }
    while(mid_node!=nullptr)
    {
        ui->tableWidget_2->setItem(mid,0, new QTableWidgetItem(QString::number(mid_node->order)));
        ui->tableWidget_2->setItem(mid,1, new QTableWidgetItem(QString::number(mid_node->customer_num)));
        mid_node=mid_node->next;
        mid++;
    }
    while(min_node!=nullptr)
    {
        ui->tableWidget_3->setItem(min,0, new QTableWidgetItem(QString::number(min_node->order)));
        ui->tableWidget_3->setItem(min,1, new QTableWidgetItem(QString::number(min_node->customer_num)));
        min_node=min_node->next;
        min++;
    }
}

void RestaurantQueue::Pause(int num,Table all_table[6][6]) //暂停餐桌定时器
{
    for(int i=0;i<num;i++)
        for(int j=0;j<num;j++)
             if(all_table[i][j].make_sure==1) all_table[i][j].time_table->stop();
}

void RestaurantQueue::Play(int num,Table all_table[6][6]) //开启餐桌定时器
{
    for(int i=0;i<num;i++)
        for(int j=0;j<num;j++)
             if(all_table[i][j].make_sure==1) all_table[i][j].time_table->start();
}

void RestaurantQueue::PauseOrPlay() //暂停或继续键
{
    int max_row_line_num=1;
    int mid_row_line_num=1;
    int min_row_line_num=1;
    while(max_row_line_num*max_row_line_num<max_table_num_)
    {
        max_row_line_num++;
    }
    while(mid_row_line_num*mid_row_line_num<mid_table_num_)
    {
        mid_row_line_num++;
    }
    while(min_row_line_num*min_row_line_num<min_table_num_)
    {
        min_row_line_num++;
    }
    switch (pause_) { //对点击暂停/继续键后，要进行的情况进行判断
    case 0:{ //要暂停的状态
            ui->pushButton_2->setIcon(QIcon(":/photo/pause.png"));
            pause_=1;
            count_time_1->stop();
            Pause(max_row_line_num,max_table);
            Pause(mid_row_line_num,mid_table);
            Pause(min_row_line_num,min_table);
            break;
    }
    case 1:{ //要继续的状态
            ui->pushButton_2->setIcon(QIcon(":/photo/play.png"));
            count_time_1->start();
            pause_=0;
            Play(max_row_line_num,max_table);
            Play(mid_row_line_num,mid_table);
            Play(min_row_line_num,min_table);
           break;
    }
    }
}

void RestaurantQueue::PutTable() //放置桌子
{
    int max_row_line_num=1;
    int mid_row_line_num=1;
    int min_row_line_num=1;
    while(max_row_line_num*max_row_line_num<max_table_num_)
    {
        max_row_line_num++;
    }
    while(mid_row_line_num*mid_row_line_num<mid_table_num_)
    {
        mid_row_line_num++;
    }
    while(min_row_line_num*min_row_line_num<min_table_num_)
    {
        min_row_line_num++;
    }
    int i=0,j=0;
    ui->tableWidget_5->verticalHeader()->setDefaultSectionSize(300/max_row_line_num); //设置行、列的宽度
    ui->tableWidget_5->horizontalHeader()->setDefaultSectionSize(300/max_row_line_num);
    ui->tableWidget_5->setColumnCount(max_row_line_num); //生成的行数、列数
    ui->tableWidget_5->setRowCount(max_row_line_num);
    while(i<max_table_num_) //开始放桌子，根据状态判断放置桌子的类型
    {
        if(max_table[j][i%max_row_line_num].make_sure==0)
        ui->tableWidget_5->setItem(j,i%max_row_line_num, new QTableWidgetItem(QIcon(":/photo/can_use.png"), " "));
        else ui->tableWidget_5->setItem(j,i%max_row_line_num, new QTableWidgetItem(QIcon(":/photo/not_use.png"), " "));
        i++;
        j=i/max_row_line_num;
        if(j<1) j=0;
    }
    i=0,j=0;
    ui->tableWidget_6->verticalHeader()->setDefaultSectionSize(300/mid_row_line_num);
    ui->tableWidget_6->horizontalHeader()->setDefaultSectionSize(300/mid_row_line_num);
    ui->tableWidget_6->setColumnCount(mid_row_line_num);
    ui->tableWidget_6->setRowCount(mid_row_line_num);
    while(i<mid_table_num_)
    { 
        if(mid_table[j][i%mid_row_line_num].make_sure==0)
        {
         ui->tableWidget_6->setItem(j,i%max_row_line_num, new QTableWidgetItem(QIcon(":/photo/can_use.png"), " "));
        }else ui->tableWidget_6->setItem(j,i%max_row_line_num, new QTableWidgetItem(QIcon(":/photo/not_use.png"), " "));
        i++;
        j=i/mid_row_line_num;
        if(j<1) j=0;
    }

    i=0,j=0;
    ui->tableWidget_7->verticalHeader()->setDefaultSectionSize(300/min_row_line_num);
    ui->tableWidget_7->horizontalHeader()->setDefaultSectionSize(300/min_row_line_num);
    ui->tableWidget_7->setColumnCount(min_row_line_num);
    ui->tableWidget_7->setRowCount(min_row_line_num);
    while(i<min_table_num_)
    {
        if(min_table[j][i%min_row_line_num].make_sure==0)
        {
         ui->tableWidget_7->setItem(j,i%min_row_line_num, new QTableWidgetItem(QIcon(":/photo/can_use.png"), " "));
        }else ui->tableWidget_7->setItem(j,i%max_row_line_num, new QTableWidgetItem(QIcon(":/photo/not_use.png"), " "));
        i++;
        j=i/min_row_line_num;
        if(j<1) j=0;
    }
}

void RestaurantQueue::ChangeTime() //真正的改变事件，重新为定时器设置时间
{
    count_time_1->setInterval(come_time_*60*1000/(speed_*20));
   // qDebug()<<speed_;
    for(int i=0;i<6;i++)
    {
        for(int j=0;j<6;j++)
        {
         max_table[i][j].time_table->setInterval(use_time_*60*1000/(speed_*20));
         min_table[i][j].time_table->setInterval(use_time_*60*1000/(speed_*20));
         mid_table[i][j].time_table->setInterval(use_time_*60*1000/(speed_*20));
        }
    }
}

void RestaurantQueue::SpeedUp(int value) //将滑块的值传给speed_
{
    speed_=value;
}

void RestaurantQueue::Close() //关闭函数
{
    QMessageBox exit_box;
    exit_box.setText("感谢您的使用");
    exit_box.setWindowTitle("退出");
    exit_box.setWindowIcon(QIcon(":/photo/leave_end.png"));
    exit_box.exec(); //一直循环
    exit(0);  //0 正常退出；非0异常退出
}

void RestaurantQueue::Warn() //警告函数
{
    warn_style_=0;
    if(ui->lineEdit_1->text()==""||ui->lineEdit_2->text()==""||ui->lineEdit_3->text()==""||ui->lineEdit_4->text()==""||ui->lineEdit_5->text()=="")
    {
        QMessageBox::critical(this, tr("警告"),  tr("请输入所有数值"),QMessageBox::Ok);
        warn_style_=1;
    }
    if(ui->lineEdit_1->text().toDouble()<=0||ui->lineEdit_2->text().toDouble()<=0||ui->lineEdit_3->text().toDouble()<=0||ui->lineEdit_4->text().toDouble()<=0||ui->lineEdit_5->text().toDouble()<=0)
    {
        QMessageBox::critical(this, tr("警告"),  tr("请输入大于0的整数"),QMessageBox::Ok);
        warn_style_=2;
    }
}

程序界面（比较粗糙

运行后截图