队列模拟（queue）

可先了解链表相关知识：链表（单向链表的建立、删除、插入、打印） - 蓝海人 - 博客园

// queue.h -- interface for a queue
#ifndef QUEUE_H_
#define QUEUE_H_
// This queue will contain Customer items
class Customer
{
private:
    long arrive;        // arrival time for customer 顾客的到达时间
    int processtime;    // processing time for customer 顾客的处理时间
public:
    Customer() : arrive(0), processtime (0){} //构造，初始化到达时间和等待处理时间
    void set(long when); //随机初始化客户等待时间，when是到达时间
    //类间函数
    long when() const { 
        return arrive; 
    }
    int ptime() const { 
        return processtime; 
    }
};

typedef Customer Item; //简化声明

//队列类
class Queue
{
private:
// class scope definitions
    // Node is a nested structure definition local to this class
    //节点，嵌套的结构体定义，一个节点里面包括当前的Customer类和下一个节点的指针
    struct Node { 
        Item item; 
        struct Node * next;
    };
    enum {Q_SIZE = 10};
// private class members
    //队列的头指针，尾指针，当前队列中Customer类数量，以及要求的队列最大数量
    Node * front;       // pointer to front of Queue
    Node * rear;        // pointer to rear of Queue
    int items;          // current number of items in Queue
    const int qsize;    // maximum number of items in Queue
    // preemptive definitions to prevent public copying
    Queue(const Queue & q) : qsize(0) { } //拷贝构造，并初始化qsize
    Queue & operator=(const Queue & q) { return *this;}
public:
    Queue(int qs = Q_SIZE); // create queue with a qs limit
    ~Queue();
    bool isempty() const;   //判断队列是否为空
    bool isfull() const;    //判断队列是否为满
    int queuecount() const; //当前队列中类数量
    bool enqueue(const Item &item); // add item to end 添加类到队列尾
    bool dequeue(Item &item);       // remove item from front 删除队列头的类
};
#endif

将类加入队列：

 

 将类出队：

 

// queue.cpp -- Queue and Customer methods
#include "queue.h"
#include <cstdlib>         // (or stdlib.h) for rand()

// Queue methods
Queue::Queue(int qs) : qsize(qs) //在构造函数{}执行前，给qsize赋值qs
{
    front = rear = NULL;    // or nullptr
    items = 0;
}

Queue::~Queue()
{
    Node * temp;
    //从链表头开始，依次删除所有的节点
    while (front != NULL)   // while queue is not yet empty
    {
        temp = front;       // save address of front item
        front = front->next;// reset pointer to next item
        delete temp;        // delete former front
    }
}

bool Queue::isempty() const
{
    return items == 0;
}

bool Queue::isfull() const
{
    return items == qsize;
}

int Queue::queuecount() const
{
    return items;
}

// Add item to queue
bool Queue::enqueue(const Item & item)
{
    if (isfull())   //如果队列满，直接返回false
        return false;
    Node * add = new Node;  // create node 创建一个新节点
// on failure, new throws std::bad_alloc exception 如果失败，会抛出异常

    //创建一个新节点时，先赋值item类对象，再将下一个节点的指向置为NULL
    add->item = item;       // set node pointers
    add->next = NULL;       // or nullptr;

    items++;    //队列存储值+1

    //做判断，如果队列头指向空，则让队列头指向新节点，否则把队列尾指向新节点
    if (front == NULL)      // if queue is empty,
        front = add;        // place item at front
    else
        rear->next = add;   // else place at rear

    rear = add;             // have rear point to new node
    return true;
}

// Place front item into item variable and remove from queue
bool Queue::dequeue(Item & item)
{
    if (front == NULL)
        return false;
    item = front->item;     // set item to first item in queue
    items--;
    Node * temp = front;    // save location of first item
    front = front->next;    // reset front to next item
    delete temp;            // delete former first item
    if (items == 0)
        rear = NULL;
    return true;
}

// customer method

// when is the time at which the customer arrives
// the arrival time is set to when and the processing
// time set to a random value in the range 1 - 3
//随机初始化客户等待时间
void Customer::set(long when)
{
    processtime = std::rand() % 3 + 1;
    arrive = when; 
}

// bank.cpp -- using the Queue interface
// compile with queue.cpp
#include <iostream>
#include <cstdlib> // for rand() and srand()
#include <ctime>   // for time()
#include "queue.h"
const int MIN_PER_HR = 60;

bool newcustomer(double x); // is there a new customer?

int main()
{
    using std::cin;
    using std::cout;
    using std::endl;
    using std::ios_base;
// setting things up
    std::srand(std::time(0));    //  random initializing of rand()

    cout << "Case Study: Bank of Heather Automatic Teller\n";
    cout << "Enter maximum size of queue: ";
    int qs;
    cin >> qs;  //假设输入3，队列中最多存3个类对象
    Queue line(qs);         // line queue holds up to qs people，初始化Queue::Queue(int qs) : qsize(qs) 

    cout << "Enter the number of simulation hours: "; //程序模拟的持续时间
    int hours;              //  hours of simulation
    cin >> hours;
    // simulation will run 1 cycle per minute 
    //每次循环为1分钟，这里输入1个小时，即60分钟
    long cyclelimit = MIN_PER_HR * hours; // # of cycles

    cout << "Enter the average number of customers per hour: ";
    double perhour;         //  average # of arrival per hour，平均每小时的客户数
    cin >> perhour;
    double min_per_cust;    //  average time between arrivals
    min_per_cust = MIN_PER_HR / perhour;

    Item temp;              //  new customer data 初始化Customer() : arrive(0), processtime (0){} 
    long turnaways = 0;     //  turned away by full queue
    long customers = 0;     //  joined the queue
    long served = 0;        //  served during the simulation
    long sum_line = 0;      //  cumulative line length
    int wait_time = 0;      //  time until autoteller is free
    long line_wait = 0;     //  cumulative time in line


// running the simulation
    for (int cycle = 0; cycle < cyclelimit; cycle++)
    {
        if (newcustomer(min_per_cust))  // have newcomer
        {
            if (line.isfull())
                turnaways++;
            else
            {
                customers++;
                temp.set(cycle);    // cycle = time of arrival，赋值到达时间，随机初始化客户等待时间
                line.enqueue(temp); // add newcomer to line
            }
        }
        if (wait_time <= 0 && !line.isempty()) //如果等待时间为0且队列非空
        {
            line.dequeue (temp);      // attend next customer
            wait_time = temp.ptime(); // for wait_time minutes
            line_wait += cycle - temp.when();
            served++;
        }
        if (wait_time > 0)
            wait_time--;
        sum_line += line.queuecount();
    }

// reporting results
    if (customers > 0)
    {
        cout << "customers accepted: " << customers << endl;
        cout << "  customers served: " << served << endl;
        cout << "         turnaways: " << turnaways << endl;
        cout << "average queue size: ";
        cout.precision(2);
        cout.setf(ios_base::fixed, ios_base::floatfield);
        cout << (double) sum_line / cyclelimit << endl;
        cout << " average wait time: "
             << (double) line_wait / served << " minutes\n";
    }
    else
        cout << "No customers!\n";
    cout << "Done!\n";
    // cin.get();
    // cin.get();
    return 0;
}

//  x = average time, in minutes, between customers
//  return value is true if customer shows up this minute
bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1); 
}