队列类实例

/////////////////////////////////////////////////////////
//////////////////////queue.h////////////////////////////
#ifndef QUEUE_H_
#define QUEUE_H_

class Customer
{
private:
 long arrive;
 int processtime;
public:
    Customer () {arrive=processtime=0;}
 void set (long when);
 long when () const {return arrive;}
 int ptime () const {return processtime;}
};

typedef Customer Item;

class Queue
{
private:
 struct Node {Item item;struct Node  * next;};
 enum {Q_SIZE=10};
 Node * front;
    Node * rear;
 int items;
 const int qsize;
    Queue (const Queue & q):qsize(0){}
    Queue & operator = (const Queue & q){return *this;}
public:
 Queue (int qs=Q_SIZE);
 ~Queue();
 bool isempty()const;
 bool isfull()const;
 int queuecount()const;
 bool enqueue(const Item & item);
 bool dequeue(Item & item);
};

#endif

 

//////////////////////////////////////////////////
/////////////////////////queue.cpp////////////////
#include "queue.h"
#include <cstdlib>

Queue::Queue(int qs):qsize(qs)
{
 front=rear=NULL;
 items=0;
}

Queue::~Queue()
{
 Node * temp;
 while (front!=NULL)
 {
  temp=front;
  front=front->next;
  delete temp;
 }
}

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

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

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

bool Queue::enqueue(const Item & item)
{
 if (isfull())
  return false;
 Node * add=new Node;
 if (add==NULL)
  return false;
 add->item=item;
 add->next=NULL;
 items++;
 if (front==NULL)
  front=add;
 else
  rear->next=add;
 rear=add;
 return true;
}

bool Queue::dequeue(Item & item)
{
 if (front==NULL)
  return false;
 item=front->item;
 items--;
    Node * temp=front;
    front=front->next;
 delete temp;
 if (items==0)
  rear=NULL;
 return true;
}

void Customer::set(long when)
{
 processtime=rand()%3+1;
 arrive=when;
}

 

 

 

//////////////////////////////////////////////////
////////////////////main.cpp//////////////////////
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "queue.h"
const int MIN_PER_HR=60;

bool newcustomer (double x);

int main(void)
{
 using std::cin;
 using std::cout;
 using std::endl;
 using std::ios_base;
    srand(time(0));

 cout<<"case study: bank of heather automatic teller\n";
 cout<<"enter maximum size of queue: ";
    int qs;
 cin>>qs;
 Queue line(qs);

 cout<<"enter the number of simulation hours: ";
 int hours;
 cin>>hours;
 long cyclelimit=MIN_PER_HR * hours;
 
 cout<<"enter the average number of customers per hour: ";
 double perhour;
 cin>>perhour;
 double min_per_cust;
 min_per_cust=MIN_PER_HR;

 Item temp;
 long turnaways=0;
 long customers=0;
 long served=0;
 long sum_line=0;
 int wait_time=0;
 long line_wait=0;

 for (int cycle=0;cycle<cyclelimit;cycle++)
 {
  if (newcustomer(min_per_cust))
  {
   if(line.isfull())
    turnaways++;
   else
   {
    customers++;
    temp.set(cycle);
    line.enqueue(temp);
   }
  }
  if (wait_time<=0 && !line.isempty())
  {
   line.dequeue(temp);
   wait_time=temp.ptime();
   line_wait+=cycle-temp.when();
   served++;
  }
  if (wait_time>0)
   wait_time--;
  sum_line+=line.queuecount();
 }

    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.setf(ios_base::showpoint);
        cout << (double) sum_line / cyclelimit << endl;
        cout << " average wait time: "
             << (double) line_wait / served << " minutes\n";
    }
    else
        cout << "No customers!\n";
   
 cout << "Done!\n";
 return 0;
}

bool newcustomer(double x)
{
    return (rand() * x / RAND_MAX < 1);
}