转载：C++ 实现银行排队服务模拟

最新推荐文章于 2024-09-20 19:58:17 发布
最新推荐文章于 2024-09-20 19:58:17 发布
阅读量2.8k 收藏 28
点赞数 2
文章标签： C++ 面向对象

转自： http://www.codeceo.com/article/bank-queuing-services-model.html

教程简介：使用 C++对银行排队服务进行模拟，以事件驱动为核心思想，手动实现模板链式队列、随机数产生器等内容，进而学习概率编程等知识。作为可选进阶，这个模型同时还能稍加修改的应用到 CPU 资源争夺模型中。

一、概述

实验所需的前置知识

  • C++ 基本语法知识

实验所巩固并运用的知识

  • OOP 编程思想
  • std::rand() 函数原理
  • 概率编程
  • 排队理论
  • 链式队列数据结构及其模板实现
  • 事件驱动的设计
  • 蒙特卡洛方法
  • C++ 动态内存管理和设计理念
  • CPU 资源争夺模型
  • 时间片轮转调度

要解决的问题

蒙特卡洛方法这个名字听起来很高大上，但它的本质其实是使用计算机的方法对问题进行模拟和复现。本次实验将使用蒙特卡洛方法来模拟银行排队这个问题：

端午节当天，某个银行从早上八点开始服务并只服务到中午十二点就停止营业。假设当天银行只提供了 w 个服务窗口进行服务，问：

  1. 平均每分钟有多少个顾客抵达银行?
  2. 平均每个顾客占用服务窗口的时间是多少？

我们先来分析一下这个业务的逻辑：

首先我们要分析银行提供服务的逻辑。在银行服务中，所有顾客都是通过取号排队的方式等待服务的，这和火车站买票有所不同，在火车站买票时，顾客必须在某一个窗口所排的队列下进行排队，且无法变更自己所属的窗口，否则只能从队尾重新排队。换句话说，对于银行提供的服务来说，所有用户都是位于同一个队列上的，当某个服务窗口可用时，才会从排队队列的队首取出一个新的用户来办理银行业务。即代码实现过程中，服务窗口可以创建 w 个，但只需要实现一个顾客队列即可。

其次，对于顾客而言，有两个属性是能够被抽象出来的：

  1. 到达银行的时间；
  2. 需要服务的时间。

并且，这两个属性是随机的。到此，我们整个的排队模型就变成了：

下面我们来详细对这个问题的实现逻辑进行分析，让我们的程序能够给出类似下面的结果：

第一部分、银行排队系统的设计与建模

一、计算机中的随机

std::rand() 函数的原理

C++ 中的 std::rand() 函数产生的随机数并不是真正意义上的随机数，它并不服从数学上的均匀分布。为了使我们的模拟系统变得更加真实，我们需要知道 std::rand() 函数的原理。

std::rand() 生成的是一个随机的二进制序列（在硬件底层更好实现），这个序列的每一位0或者1的概率都是相等的。而对于 std::rand()%n 这个运算，会在 [0, n-1] 之间生成随机数，所以，如果 n-1 的二进制表示的值不都是由 1 组成，那么这里面的数是不会从均匀分布了（因为某些位可能不能为 1）。

所以，当且仅当 [0, n-1] 中的随机数可以用这个序列的子序列表示时，才能满足均匀分布。换句话说，仅当 n-1 的二进制数全为1 时，0，1出现的概率才是均等的。

我们先来实现随机这个类：

//
//  Random.hpp
//  QueueSystem
//

#ifndef Random_hpp
#define Random_hpp

#include <cstdlib>
#include <cmath>

class Random {
public:
    // [0, 1) 之间的服从均匀分布的随机值
    static double uniform(double max = 1) {
        return ((double)std::rand() / (RAND_MAX))*max;
    }
};
#endif /* Random_hpp */

这样的话，当我们调用 Random::uniform() 时，便能获得真正的服从均匀分布的随机数了。当指定参数后，便能够生成 [0, max) 之间的随机值了。

二、主函数逻辑设计

对于一个银行而言，对外界来说只需要提供两个参数：

  1. 总共的服务时间
  2. 服务窗口的数量

所以我们希望实现这样的代码：

//
// main.cpp
// QueueSystem
//

#include "QueueSystem.hpp"

#include <iostream>
#include <cstdlib>

int main() {

    std::srand((unsigned)std::time(0)); // 使用当前时间作为随机数种子

    int total_service_time = 240;       // 按分钟计算
    int window_num         = 4;
    int simulate_num       = 100000;    // 模拟次数

    QueueSystem system(total_service_time, window_num);
    system.simulate(simulate_num);

    std::cout << "The average time of customer stay in bank: "
              << system.getAvgStayTime() << std::endl;
    std::cout << "The number of customer arrive bank per minute: "
              << system.getAvgCustomers() << std::endl;

    return 0;
}

三、对象及逻辑设计

总结一下，现在我们需要实现的东西有：

  1. 服务窗口类(会被创建 w 个)
  2. 顾客队列类(只会被创建一个)
  3. 顾客结构(包含两个随机属性: 到达时间, 服务时间)

为了更好练习 C++，我们会弃用诸如 vector 这些快捷编码的标准库来进行『过度编码』，自行编写模板类。

根据前面的问题描述，我们可以初步确定这样一些类的设计需求：

  1. QueueSystem 类: 负责整个队列系统的模拟；
  2. ServiceWindow 类: 队列系统的服务窗口对象，每当一个银行创建时，服务窗口会被创建，为了让整个问题更加灵活，我们假设需要创建 window_num 个窗口；
  3. Queue 类: 银行队列系统的顾客排队的队列；
  4. Random 类: 在第二节中已经讨论过。

然而，在设计 ServiceWindow 之前，我们要考虑 ServiceWindow 类到底要放置什么成员，首先，对于一个服务窗口，会有一个顾客属性，用于存放顾客。另一方面，一个窗口只会有两种状态：要么正在服务（被占用），要么空闲。因此 ServiceWindow 中首先会有下面的枚举：

//
// ServiceWindow.hpp
// QueueSystem
//

enum WindowStatus {
    SERVICE,
    IDLE,
};

既然我们要在 ServiceWindow 中存放顾客，由于顾客本身并不需要提供什么方法，因此可以直接将顾客设计为一个结构体 Customer，同时，顾客也会成为等待队列中的一员。所以，Customer 也可以被称之为队列的一个 Node，此外，每个顾客说需要的服务时间是随机的，但是到达时间并不应该由顾客自身确定（我们在下一节再讨论为什么），所以Customer结构的默认构造应该被设计出来：

//
//  Node.h
//  QueueSystem
//

#ifndef Node_h
#define Node_h

#include "Random.hpp"

#define RANDOM_PARAMETER 100

struct Node {
    int arrive_time;
    int duration;
    struct Node *next;

    // 默认到达事件为0，需要服务的事件是随机的
    Node(int arrive_time = 0,
         int duration = Random::uniform(RANDOM_PARAMETER)):
        arrive_time(arrive_time),
        duration(duration),
        next(nullptr) {}
};

typedef struct Node Node;
typedef struct Node Customer;

#endif /* Node_h */

那么，结合前面的 WindowStatus枚举和 Customer结构，我们的 ServiceWindow 类可以这样设计，因为窗口本身涉及的操作还算是比较简单，比如设置窗口状态是否繁忙，获取当前服务顾客的到达时间来方便后续计算等等，因此我们直接将其设计成类内的 inline 函数：

//
//  ServiceWindow.hpp
//  QueueSystem
//

#ifndef ServiceWindow_hpp
#define ServiceWindow_hpp

#include "Node.hpp"

enum WindowStatus {
    SERVICE,
    IDLE,
};

class ServiceWindow {
public:
    inline ServiceWindow() {
        window_status = IDLE;
    };
    inline bool isIdle() const {
        if (window_status == IDLE) {
            return true;
        } else {
            return false;
        }
    }
    inline void serveCustomer(Customer &customer) {
        this->customer = customer;
    }
    inline void setBusy() {
        window_status = SERVICE;
    }
    inline void setIdle() {
        window_status = IDLE;
    }
    inline int getCustomerArriveTime() const {
        return customer.arrive_time;
    }
    inline int getCustomerDuration() const {
        return customer.duration;
    }
private:
    Customer customer;
    WindowStatus window_status;
};

#endif /* ServiceWindow_hpp */

三、事件驱动的设计

有了上面的这些设计，似乎我们只要编写好用户排队队列，就已经足够描述整个排队的系统了，然而，在上面的设计中，还有一个很大的问题，那就是：整个系统还处于静止状态。当顾客位于等待队列时，窗口什么时候服务下一个顾客，如何处理这里面的逻辑，到目前为止，我们都没有思考过。

为了让整个系统『运行』起来，我们还要考虑整个系统的运行时间线。这里我们给出一种事件驱动的设计。

在前面的分析中，我们知道整个系统中，无非出现两种事件：

  1. 有顾客到达
  2. 有顾客离开

其中，第二种顾客离开的事件，同时还包含了窗口服务等待队列中的下一个顾客这个事件。所以，我们如果能够维护一个事件列表，那么就能够驱动整个队列系统的运行了。因为，当事件发生时，我们通知这个队列系统更新他自身的状态即可。

综上所述，我们可以先设计事件表中的事件结构：

//
//  Event.hpp
//  QueueSystem
//

#ifndef Event_hpp
#define Event_hpp

#include "Random.hpp"
#define RANDOM_PARAMETER 100

struct Event {
    int occur_time;

    // 使用 -1 表示到达事件, >=0 表示离开事件, 同时数值表示所离开的服务窗口
    int event_type;

    Event* next;

    // 默认为到达事件，发生事件随机
    Event(int occur_time = Random::uniform(RANDOM_PARAMETER),
          int event_type = -1):
        occur_time(occur_time),
        event_type(event_type),
        next(nullptr) {}
};

#endif /* Event_hpp */

这里我们使用了一个小小的 trick，那就是用整数来表示事件的类型，而不是简单的使用枚举。

这是因为，对于 ServiceWindow 来说，我们可以使用数组来管理多个 ServiceWindow，那么对应的事件类型如果涉及为整数，事件类型就可以同时作为 ServiceWindow 的索引下标了，当 event_type 大于等于 0 时，数值还表示离开的服务窗口。

又因为事件列表、顾客队列，本质上可以归类为同一个结构，那就是队列：只不过他们的入队方式有所差异，对于事件列表而言，入队方式必须按发生事件的时间顺序入队，而对于顾客，则是直接添加到队尾。考虑到了这一点，我们便能很容易的利用模板来设计队列的基本需求了：

//
//  Queue.hpp
//  QueueSystem
//

#ifndef Queue_hpp
#define Queue_hpp

#include <iostream>
#include <cstdlib>

#include "Event.hpp"

// 带头结点的队列
template <typename T>
class Queue
{
public:
    Queue();
    ~Queue();
    void clearQueue();             // 清空队列
    T* enqueue(T &node);
    T* dequeue();
    T* orderEnqueue(Event &event); // 只适用于事件入队
    int  length();
private:
    T *front;  // 头结点
    T *rear;   // 队尾
};
#endif /* Queue_hpp */

四、QueueSystem

经过前面的讨论，我们已经完成了对所有基本结构的设计，根据这些设计，我们能够初步确定我们要实现的队列系统的基本结构。

首先，根据对主函数的设计，初始化整个队列系统我们需要两个参数：

  1. 银行的总服务时间(分钟) int total_service_time
  2. 银行开放的服务窗口数 int window_num

其次，我们需要 QueueSystem 发开放至少三个接口：

  1. 模拟 simulate()
  2. 获得顾客平均逗留时间 getAvgStayTime()
  3. 获得平均每分钟顾客数 getAvgCustomers()

第三，内部需要实现的内容包括：

  1. 系统运行前的初始化 init()
  2. 让系统运行的 run()
  3. 系统结束一次运行的清理工作 end()

第四，整个系统需要管理的核心成员有：

  1. 可供服务的窗口 ServiceWindow* windows
  2. 顾客等待队列 Queue<Customer> customer_list
  3. 事件列表 Queue<Event> event_list
  4. 当前的系统事件 Event* current_event

第五，处理事件的方法：

  1. 处理顾客到达事件 void customerArrived()
  2. 处理顾客离开事件 void customerDeparture()

最后，我们所希望的平均顾客逗留时间和平均每分钟的顾客数涉及的四个变量：

  1. 顾客的总逗留时间 int total_customer_stay_time
  2. 一次运行中系统服务的中顾客数量 int total_customer_num
  3. 每分钟平均顾客数 double avg_customers
  4. 顾客平均逗留时间 double avg_stay_time

事实上，可以预见的是，在处理顾客服务逻辑的时候，我们还需要一个方法getIdleServiceWindow 来获取当前服务窗口的状态，从而增加代码的复用度。

所以，整个 QueueSystem 类的代码设计为：

//
//  QueueSystem.hpp
//  QueueSystem
//

#ifndef QueueSystem_hpp
#define QueueSystem_hpp

#include "Event.hpp"
#include "Queue.hpp"
#include "ServiceWindow.hpp"

class QueueSystem {

public:
    // 初始化队列系统
    QueueSystem(int total_service_time, int window_num);

    // 销毁
    ~QueueSystem();

    // 启动模拟
    void simulate(int simulate_num);

    inline double getAvgStayTime() {
        return avg_stay_time;
    }
    inline double getAvgCustomers() {
        return avg_customers;
    }

private:
    // 让队列系统运行一次
    double run();

    // 初始化各种参数
    void init();

    // 清空各种参数
    void end();

    // 获得空闲窗口索引
    int getIdleServiceWindow();

    // 处理顾客到达事件
    void customerArrived();

    // 处理顾客离开事件
    void customerDeparture();

    // 服务窗口的总数
    int window_num;

    // 总的营业时间
    int total_service_time;

    // 顾客的逗留总时间
    int customer_stay_time;

    // 总顾客数
    int total_customer_num;

    // 核心成员
    ServiceWindow*  windows;
    Queue<Customer> customer_list;
    Queue<Event>       event_list;
    Event*          current_event;

    // 给外部调用的结果
    double avg_customers;
    double avg_stay_time;

};

#endif /* QueueSystem_hpp */

本节回顾

在这一节中，我们设计了整个银行排队系统的基本逻辑，并借鉴了事件驱动的思想设计了驱动队列系统的事件类。本节中我们一共创建了：

  1. Event.hpp
  2. Node.hpp
  3. Queue.hpp
  4. Random.hpp
  5. ServiceWindow.hpp
  6. QueueSystem.hpp
  7. main.cpp

现在我们的代码还不能够直接运行，本节我们先关注理清我们的业务逻辑。在下一节中，我们将实现这些代码的详细逻辑，这包括：

  1. Queue.hpp 中模板链式队列的具体实现
  2. QueueSystem.cpp 中的详细服务逻辑
  3. Random.hpp 中更复杂的随机概率分布

在这些实现中，我们将进一步巩固下面的知识的运用：

  1. C++ 类模板
  2. 链式队列的数据结构
  3. 概率编程
  4. C++ 中内存管理和设计理念

Daryl_D
关注
2024华为OD机考机试E卷 +C卷 + D卷 + B卷 + A卷：真题目录 + 考点说明
算法大师！
03-18 39万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
代码面试之栈和队列(转载)
李肖遥的专栏
09-30 156
1.1栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满：...
C++银行排队系统模拟
11-20
C++小程序开发，银行排队模拟。包含整个系统的讲解，以及全部的代码。
银行排队系统模拟c++
05-25
模拟一个银行排队系统采用离散事件驱动
C/C++模拟银行排队叫号系统
最新发布
gitblog_06536的博客
09-20 963
C/C++模拟银行排队叫号系统 CC模拟银行排队叫号系统2023-05-11 项目地址: https://gitcode.com/Resource-Bundle-Collection/4d473 ...
c 语言银行排队系统,C++实现银行排队系统
weixin_30127493的博客
05-23 1608
#include #include #include int cnt=0; //当日客流量int sum=0; //当日客户排队总时间typedef struct pnode{int number;int cometime;int leavetime;struct pnode *next;}*person;typedef struct node{person front;person rear;i...
银行排队算法实现C++
m0_62765133的博客
09-12 2188
数据结构银行排队算法实现C++
C++ 实现银行排队服务模拟
06-19
C++ 实现银行排队服务模拟
银行排队模拟（队列，模拟，数据结构）
weixin_30756499的博客
03-27 1468
问题描述： 已知： （1）银行有多个窗口 （2）存在不同优先级的客户 要求： （1）模拟计算客户的到达，服务，离开的过程 （2）模拟计算客户的总逗留事件。 思路： 3种解决方向 1.STL队列与vector实现该问题。 2.C语言数据结构实现链式链表实现该问题。 3.C++面向对象程序设计结合事件驱动编程。 实现： 设计一个队列类（C++prime ...
【啊哈！算法】算法4：队列——解密QQ号
啊哈磊的专栏
03-10 5156
新学期开始了，小哈是小哼的新同桌（小哈是个小美女哦~），小哼向小哈询问QQ号，小哈当然不会直接告诉小哼啦，原因嘛你懂的。所以小哈给了小哼一串加密过的数字，同时小哈也告诉了小哼解密规则。规则是这样的：首先将第1个数删除，紧接着将第2个数放到这串数的末尾，再将第3个数删除并将第4个数再放到这串数的末尾，再将第5个数删除……直到剩下最后一个数，将最后一个数也删除。按照刚才删除的顺序，把这些删除的数连在一
2024华为OD机试真题目录 B+C+D+E卷，使用Java语言进行解答（560道）
热门推荐
KJ.JK
09-20 4万+
本文是华为OD机试真题（Java 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
C++实现银行排队系统
08-30
主要为大家详细介绍了C++实现银行排队系统，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++面向对象模拟仿真银行排队系统
07-10
C++面向对象模拟仿真银行排队系统，可用到其他模拟仿真系统
C++事件驱动型银行排队模拟
09-01
主要为大家详细介绍了C++事件驱动型银行排队模拟,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C/C++ 银行排队仿真系统
my_angle2016的博客
11-24 1337
基本功能：模拟一个单队列、多窗口的银行排队系统一天的运行情况，随机生成顾客的到达时间和办理业务所需时间等数据。一天结束后，统计顾客的平均等待时间和窗口的平均占用率(1)改变顾客办理业务所需时间或银行的窗口数，观察顾客平均等待时间和窗口平均占用率如何变化；(2)假设每位顾客有一个容忍时间，等待超过容忍时间之后顾客将离开，统计顾客的离开率；(3)假设银行有两个队列，其中一个是VIP队列，另一个是普通队列，窗口服务的规则改为：若VIP队列不空，则优先服务VIP，否则服务普通顾客，统计VIP和普通顾客的平均等待时间
小项目分析之C++ 实现模拟银行排队
weixin_34218890的博客
05-25 699
一、问题定义与分析 问题定义 •要解决的问题——银行一天之内的： 1.总客户数 2.客户总逗留时间 3.客户平均逗留时间 问题分析 •新来的人找个短的队伍，站在队尾开始排队 •排在队头的人可以办理业务 •排队等待办业务的客户是在分散的、随机的时间点到来的 •特点：离散事件、要排队 •掌握每个客户到达银行和离开银行这两个时刻 •统计出客户总...
C++实现银行排队服务模拟：概率编程与蒙特卡洛方法
总结，本实验旨在通过C++实现银行排队服务模拟，涵盖了OOP编程、随机数生成、概率编程、队列数据结构、事件驱动设计、蒙特卡洛方法等多方面知识。通过这个模拟，我们可以学习到如何用编程语言来解决实际问题，同时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值