Redo the simulation program of Chapter 17 so that it uses the STL class queue to

ID: 3560834 • Letter: R

Question

Redo the simulation program of Chapter 17 so that it uses the STL class queue to maintain the list of waiting customers.

This has stumped me for a week now. I would really apprieciate your help.

Chapter 17 Code:
All my code is 100% correct.

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

#include "simulation.h"
#include "queueAsArray.h"

using namespace std;

void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival);
bool isCustomerArrived(double arvTimeDiff);

void generateStatistics(serverListType& serverList,
                       waitingCustomerQueueType& CQueue,
                       int numOfCustArrived,
                       int waitTimeServedCustomers);
void runSimulation();

int main()
{
runSimulation();

system("pause");
return 0;
}

void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival)
{
cout << "Enter the simulation time: ";
cin >> sTime;
cout << endl;

cout << "Enter the number of servers: ";
cin >> numOfServers;
cout << endl;

cout << "Enter the transaction time: ";
cin >> transTime;
cout << endl;

cout << "Enter the time between customer arrivals: ";
cin >> tBetweenCArrival;
cout << endl;
}

bool isCustomerArrived(double arvTimeDiff)
{
double value;

value = static_cast<double> (rand()) / static_cast<double>(RAND_MAX);

return (value > exp(- 1.0/arvTimeDiff));
}

void runSimulation()
{
int simulationTime;
int numberOfServers;
int transactionTime;
int timeBetweenCustomerArrival;

waitingCustomerQueueType customerQueue;

customerType customer;

int custNumber = 0;

int totalWaitTimeServedCustomers = 0;
int totalWaitTime = 0;
int numberOfCustomersServed = 0;
int customersLeftInServers = 0;
int clock = 0;
int serverID;

setSimulationParameters(simulationTime, numberOfServers,
transactionTime, timeBetweenCustomerArrival);

serverListType serverList(numberOfServers);

for (clock = 1; clock <= simulationTime; clock++)
{
serverList.updateServers(cout);

if (!customerQueue.isEmptyQueue())
customerQueue.updateWaitingQueue();

if (isCustomerArrived(timeBetweenCustomerArrival))
{
custNumber++;
customer.setCustomerInfo(custNumber, clock, 0,
transactionTime);
customerQueue.addQueue(customer);
cout << "Customer number " << custNumber
<< " arrived at time unit " << clock << endl;
}

serverID = serverList.getFreeServerID();
if (serverID != -1 && !customerQueue.isEmptyQueue())
{
customer = customerQueue.front();
customerQueue.deleteQueue();
totalWaitTimeServedCustomers = totalWaitTimeServedCustomers
+ customer.getWaitingTime();
serverList.setServerBusy(serverID, customer);
}
}

cout << endl;

cout << "The simulation ran for " << simulationTime
<< " time units" << endl;
cout << "Number of servers: " << numberOfServers << endl;
cout << "Average transaction time: "
<< transactionTime << endl;
cout << "Average arrival time difference between customers: "
<< timeBetweenCustomerArrival << endl;

generateStatistics(serverList, customerQueue,
custNumber, totalWaitTimeServedCustomers);
}

void generateStatistics(serverListType& serverList,
waitingCustomerQueueType& CQueue,
int numOfCustArrived,
int waitTimeServedCustomers)
{
int customersLeftInQueue = 0;

int totalWaitTime = waitTimeServedCustomers;

customerType customer;

while (!CQueue.isEmptyQueue())
{
customer = CQueue.front();
CQueue.deleteQueue();
totalWaitTime = totalWaitTime + customer.getWaitingTime();
customersLeftInQueue++;
}

//Find number of customers left in servers
int customersLeftInServers = serverList.getNumberOfBusyServers();
//Find number of customers completely served
int numberOfCustomersServed = numOfCustArrived - customersLeftInServers -
customersLeftInQueue;

double averageWaitTime = 0;

cout << "Total waiting time: " << totalWaitTime << endl;
cout << "Number of customers that completed a transaction: "
<< numberOfCustomersServed << endl;
cout << "Number of customers left in the servers: "
<< customersLeftInServers << endl;
cout << "The number of customers left in queue: " << customersLeftInQueue
<< endl;

if (numOfCustArrived > 0) // If number of customers arrived is > 0
averageWaitTime = (static_cast<double>(totalWaitTime)) / numOfCustArrived;

cout << fixed << showpoint;
cout << setprecision(2);
cout << "Average waiting time: " << averageWaitTime << endl;
cout << "************** END SIMULATION *************" << endl;

__________________________________________________________________
simulation.h :

#include <fstream>
#include <string>
#include "queueAsArray.h"

using namespace std;

//**************** customerType ****************
class customerType
{
public:
customerType(int cN = 0, int arrvTime = 0, int wTime = 0,
int tTime = 0);
//Constructor to initialize the instance variables
//according to the parameters
//If no value is specified in the object declaration,
//the default values are assigned.
//Postcondition: customerNumber = cN;
// arrivalTime = arrvTime;
// waitingTime = wTime;
// transactionTime = tTime

void setCustomerInfo(int customerN = 0, int inTime = 0,
int wTime = 0, int tTime = 0);
//Function to initialize the instance variables.
//Instance variables are set according to the parameters.
//Postcondition: customerNumber = customerN;
// arrivalTime = arrvTime;
// waitingTime = wTime;
// transactionTime = tTime;

int getWaitingTime() const;
//Function to return the waiting time of a customer.
//Postcondition: The value of waitingTime is returned.

void setWaitingTime(int time);
//Function to set the waiting time of a customer.
//Postcondition: waitingTime = time;

void incrementWaitingTime();
//Function to increment the waiting time by one time unit.
//Postcondition: waitingTime++;

int getArrivalTime() const;
//Function to return the arrival time of a customer.
//Postcondition: The value of arrivalTime is returned.

int getTransactionTime() const;
//Function to return the transaction time of a customer.
//Postcondition: The value of transactionTime is returned.

int getCustomerNumber() const;
//Function to return the customer number.
//Postcondition: The value of customerNumber is returned.

private:
int customerNumber;
int arrivalTime;
int waitingTime;
int transactionTime;
};

//************* serverType ****************
class serverType
{
public:
serverType();
//Default constructor
//Sets the values of the instance variables to their default
//values.
//Postcondition: currentCustomer is initialized by its
// default constructor; status = "free"; and
// the transaction time is initialized to 0.

bool isFree() const;
//Function to determine if the server is free.
//Postcondition: Returns true if the server is free,
// otherwise returns false.

void setBusy();
//Function to set the status of the server to busy.
//Postcondition: status = "busy";

void setFree();
//Function to set the status of the server to "free".
//Postcondition: status = "free";

void setTransactionTime(int t);
//Function to set the transaction time according to the
//parameter t.
//Postcondition: transactionTime = t;

void setTransactionTime();
//Function to set the transaction time according to
//the transaction time of the current customer.
//Postcondition:
// transactionTime = currentCustomer.transactionTime;

int getRemainingTransactionTime() const;
//Function to return the remaining transaction time.
//Postcondition: The value of transactionTime is returned.

void decreaseTransactionTime();
//Function to decrease the transactionTime by 1 unit.
//Postcondition: transactionTime--;

void setCurrentCustomer(customerType cCustomer);
//Function to set the info of the current customer
//according to the parameter cCustomer.
//Postcondition: currentCustomer = cCustomer;

int getCurrentCustomerNumber() const;
//Function to return the customer number of the current
//customer.
//Postcondition: The value of customerNumber of the
// current customer is returned.

int getCurrentCustomerArrivalTime() const;
//Function to return the arrival time of the current
//customer.
//Postcondition: The value of arrivalTime of the current
// customer is returned.

int getCurrentCustomerWaitingTime() const;
//Function to return the current waiting time of the
//current customer.
//Postcondition: The value of transactionTime is
// returned.

int getCurrentCustomerTransactionTime() const;
//Function to return the transaction time of the
//current customer.
//Postcondition: The value of transactionTime of the
// current customer is returned.

private:
customerType currentCustomer;
string status;
int transactionTime;
};

//************* serverListType ****************
class serverListType
{
public:
serverListType(int num = 1);
//Constructor to initialize a list of servers
//Postcondition: numOfServers = num
// A list of servers, specified by num,
// is created and each server is
// initialized to "free".

~serverListType();
//Destructor
//Postcondition: The list of servers is destroyed.

int getFreeServerID() const;
//Function to search the list of servers.
//Postcondition: If a free server is found, returns
// its ID; otherwise, returns -1.

int getNumberOfBusyServers() const;
//Function to return the number of busy servers.
//Postcondition: The number of busy servers is returned.

void setServerBusy(int serverID, customerType cCustomer,
int tTime);
//Function to set a server as busy.
//Postcondition: The server specified by serverID is set
// to "busy", to serve the customer
// specified by cCustomer, and the
// transaction time is set according to the
// parameter tTime.

void setServerBusy(int serverID, customerType cCustomer);
//Function to set a server as busy.
//Postcondition: The server specified by serverID is set
// to "busy", to serve the customer
// specified by cCustomer.

void updateServers(ostream& outFile);
//Function to update the status of a server.
//Postcondition: The transaction time of each busy
// server is decremented by one unit. If
// the transaction time of a busy server
// is reduced to zero, the server is set
// to "free". Moreover, if the actual
// parameter corresponding to outFile is
// cout, a message indicating which customer
// has been served is printed on the screen,
// together with the customer's departing
// time. Otherwise, the output is sent to
// a file specified by the user.

private:
int numOfServers;
serverType *servers;
};

//**************** waitQueue *************

class waitingCustomerQueueType: public queueType<customerType>
{
public:
waitingCustomerQueueType(int size = 100);
//Constructor
//Postcondition: The queue is initialized according to
// the parameter size. The value of size
// is passed to the constructor of queueType.

void updateWaitingQueue();
//Function to increment the waiting time of each
//customer in the queue by one time unit.
};

//*************** customerType ************

void customerType::setCustomerInfo(int customerN, int arrvTime,
int wTime, int tTime)
{
customerNumber = customerN;
arrivalTime = arrvTime;
waitingTime = wTime;
transactionTime = tTime;
}

customerType::customerType(int customerN, int arrvTime, int wTime,
int tTime)
{
setCustomerInfo(customerN, arrvTime, wTime, tTime);
}

int customerType::getWaitingTime() const
{
return waitingTime;
}

void customerType::incrementWaitingTime()
{
waitingTime++;
}

void customerType::setWaitingTime(int time)
{
waitingTime = time;
}

int customerType::getArrivalTime() const
{
return arrivalTime;
}

int customerType::getTransactionTime() const
{
return transactionTime;
}

int customerType::getCustomerNumber() const
{
return customerNumber;
}
//**************** serverType **********

serverType::serverType()
{
status = "free";
transactionTime = 0;
}

bool serverType::isFree() const
{
return (status == "free");
}

void serverType::setBusy()
{
status = "busy";
}

void serverType::setFree()
{
status = "free";
}

void serverType::setTransactionTime(int t)
{
transactionTime = t;
}

void serverType::setTransactionTime()
{
int time;

time = currentCustomer.getTransactionTime();

transactionTime = time;
}

void serverType::decreaseTransactionTime()
{
transactionTime--;
}

int serverType::getRemainingTransactionTime() const
{
return transactionTime;
}

void serverType::setCurrentCustomer(customerType cCustomer)
{
currentCustomer = cCustomer;
}

int serverType::getCurrentCustomerNumber() const
{
return currentCustomer.getCustomerNumber();
}

int serverType::getCurrentCustomerArrivalTime() const
{
return currentCustomer.getArrivalTime();
}

int serverType::getCurrentCustomerWaitingTime() const
{
return currentCustomer.getWaitingTime();
}

int serverType::getCurrentCustomerTransactionTime() const
{
return currentCustomer.getTransactionTime();
}

//************** serverListType ***********

serverListType::serverListType(int num)
{
numOfServers = num;
servers = new serverType[num];
}

serverListType::~serverListType()
{
delete [] servers;
}

int serverListType::getFreeServerID() const
{
int serverID = -1;

int i;

for (i = 0; i < numOfServers; i++)
if (servers[i].isFree())
{
serverID = i;
break;
}

return serverID;
}

int serverListType::getNumberOfBusyServers() const
{
int busyServers = 0;

int i;

for (i = 0; i < numOfServers; i++)
if (!servers[i].isFree())
busyServers++;

return busyServers;
}

void serverListType::setServerBusy(int serverID,
customerType cCustomer,
int tTime)
{
servers[serverID].setBusy();
servers[serverID].setTransactionTime(tTime);
servers[serverID].setCurrentCustomer(cCustomer);
}

void serverListType::setServerBusy(int serverID,
customerType cCustomer)
{
int time;

time = cCustomer.getTransactionTime();

   servers[serverID].setBusy();
   servers[serverID].setTransactionTime(time);
   servers[serverID].setCurrentCustomer(cCustomer);
}

void serverListType::updateServers(ostream& outFile)
{
int i;

for (i = 0; i < numOfServers; i++)
if (!servers[i].isFree())
{
servers[i].decreaseTransactionTime();

if (servers[i].getRemainingTransactionTime() == 0)
{
outFile << "From server number " << (i + 1)
<< " customer number "
<< servers[i].getCurrentCustomerNumber()
<< " departed at time unit "
<< servers[i].
getCurrentCustomerArrivalTime()
+ servers[i].
getCurrentCustomerWaitingTime()
+ servers[i].
getCurrentCustomerTransactionTime()
<< endl;
servers[i].setFree();
}
}
}

//*************** waitQueue ************

waitingCustomerQueueType::waitingCustomerQueueType(int size)
:queueType<customerType>(size)
{
}

void waitingCustomerQueueType::updateWaitingQueue()
{
customerType cust;

cust.setWaitingTime(-1);
int wTime = 0;

addQueue(cust);

while (wTime != -1)
{
cust = front();
deleteQueue();

wTime = cust.getWaitingTime();
if (wTime == -1)
break;
cust.incrementWaitingTime();
addQueue(cust);
}
}

_______________________________________________________________

QueueAsArray.h

//Header file QueueAsArray

#ifndef H_QueueAsArray
#define H_QueueAsArray

#include <iostream>
#include <cassert>
using namespace std;

template <class Type>
class queueType
{
public:
const queueType<Type>& operator=(const queueType<Type>&);
//Overload the assignment operator.

bool isEmptyQueue() const;
//Function to determine whether the queue is empty.
//Postcondition: Returns true if the queue is empty,
// otherwise returns false.

bool isFullQueue() const;
//Function to determine whether the queue is full.
//Postcondition: Returns true if the queue is full,
// otherwise returns false.

void initializeQueue();
//Function to initialize the queue to an empty state.
//Postcondition: The queue is empty.

Type front() const;
//Function to return the first element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: If the queue is empty, the program
// terminates; otherwise, the first
// element of the queue is returned.
Type back() const;
//Function to return the last element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: If the queue is empty, the program
// terminates; otherwise, the last
// element of the queue is returned.

void addQueue(const Type& queueElement);
//Function to add queueElement to the queue.
//Precondition: The queue exists and is not full.
//Postcondition: The queue is changed and queueElement
// is added to the queue.

void deleteQueue();
//Function to remove the first element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: The queue is changed and the first
// element is removed from the queue.

queueType(int queueSize = 100);
//Constructor

queueType(const queueType<Type>& otherQueue);
//Copy constructor

~queueType();
//Destructor

private:
int maxQueueSize; //variable to store the maximum queue size
int count; //variable to store the number of
//elements in the queue
int queueFront; //variable to point to the first
//element of the queue
int queueRear; //variable to point to the last
//element of the queue
Type *list; //pointer to the array that holds
//the queue elements
};

template <class Type>
bool queueType<Type>::isEmptyQueue() const
{
return (count == 0);
} //end isEmptyQueue

template <class Type>
bool queueType<Type>::isFullQueue() const
{
return (count == maxQueueSize);
} //end isFullQueue

template <class Type>
void queueType<Type>::initializeQueue()
{
queueFront = 0;
queueRear = maxQueueSize - 1;
count = 0;
} //end initializeQueue

template <class Type>
Type queueType<Type>::front() const
{
assert(!isEmptyQueue());
return list[queueFront];
} //end front

template <class Type>
Type queueType<Type>::back() const
{
assert(!isEmptyQueue());
return list[queueRear];
} //end back

template <class Type>
void queueType<Type>::addQueue(const Type& newElement)
{
if (!isFullQueue())
{
queueRear = (queueRear + 1) % maxQueueSize; //use mod
//operator to advance queueRear
//because the array is circular
count++;
list[queueRear] = newElement;
}
else
cout << "Cannot add to a full queue." << endl;
} //end addQueue

template <class Type>
void queueType<Type>::deleteQueue()
{
if (!isEmptyQueue())
{
count--;
queueFront = (queueFront + 1) % maxQueueSize; //use the
//mod operator to advance queueFront
//because the array is circular
}
else
cout << "Cannot remove from an empty queue." << endl;
} //end deleteQueue

//Constructor
template <class Type>
queueType<Type>::queueType(int queueSize)
{
if (queueSize <= 0)
{
cout << "Size of the array to hold the queue must "
<< "be positive." << endl;
cout << "Creating an array of size 100." << endl;

maxQueueSize = 100;
}
else
maxQueueSize = queueSize; //set maxQueueSize to
//queueSize

queueFront = 0; //initialize queueFront
queueRear = maxQueueSize - 1; //initialize queueRear
count = 0;
list = new Type[maxQueueSize]; //create the array to
//hold the queue elements
} //end constructor

//Destructor
template <class Type>
queueType<Type>::~queueType()
{
delete [] list;
} //end destructor

template <class Type>
const queueType<Type>& queueType<Type>::operator=
(const queueType<Type>& otherQueue)
{
cout << "Write the definition of the function "
<< "to overload the assignment operator." << endl;
} //end assignment operator

template <class Type>
queueType<Type>::queueType(const queueType<Type>& otherQueue)
{
cout << "Write the definition of the copy constructor."
<< endl;
} //end copy constructor

#endif

Explanation / Answer

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

#include "simulation.h"

using namespace std;

void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival);
bool isCustomerArrived(double arvTimeDiff);

void generateStatistics(serverListType& serverList,
queue<customerType>& CQueue,
int numOfCustArrived,
int waitTimeServedCustomers);
void runSimulation();

int main()
{
runSimulation();

system("pause");
return 0;
}

void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival)
{
cout << "Enter the simulation time: ";
cin >> sTime;
cout << endl;

cout << "Enter the number of servers: ";
cin >> numOfServers;
cout << endl;

cout << "Enter the transaction time: ";
cin >> transTime;
cout << endl;

cout << "Enter the time between customer arrivals: ";
cin >> tBetweenCArrival;
cout << endl;
}

bool isCustomerArrived(double arvTimeDiff)
{
double value;

value = static_cast<double> (rand()) / static_cast<double>(RAND_MAX);

return (value > exp(-1.0 / arvTimeDiff));
}

void runSimulation()
{
int simulationTime;
int numberOfServers;
int transactionTime;
int timeBetweenCustomerArrival;

queue<customerType> customerQueue;

customerType customer;

int custNumber = 0;

int totalWaitTimeServedCustomers = 0;
int totalWaitTime = 0;
int numberOfCustomersServed = 0;
int customersLeftInServers = 0;
int clock = 0;
int serverID;

setSimulationParameters(simulationTime, numberOfServers,
transactionTime, timeBetweenCustomerArrival);

serverListType serverList(numberOfServers);

for (clock = 1; clock <= simulationTime; clock++)
{
serverList.updateServers(cout);

if (!customerQueue.empty())
{
for (int sz = customerQueue.size(); sz > 0; sz--)
{
customerType cust = customerQueue.front();
customerQueue.pop();
cust.incrementWaitingTime();
customerQueue.push(cust);
}
}

if (isCustomerArrived(timeBetweenCustomerArrival))
{
custNumber++;
customer.setCustomerInfo(custNumber, clock, 0,
transactionTime);
customerQueue.push(customer);
cout << "Customer number " << custNumber
<< " arrived at time unit " << clock << endl;
}

serverID = serverList.getFreeServerID();
if (serverID != -1 && !customerQueue.empty())
{
customer = customerQueue.front();
customerQueue.pop();
totalWaitTimeServedCustomers = totalWaitTimeServedCustomers
+ customer.getWaitingTime();
serverList.setServerBusy(serverID, customer);
}
}

cout << endl;

generateStatistics(serverList, customerQueue,
custNumber, totalWaitTimeServedCustomers);
}

void generateStatistics(serverListType& serverList,
queue<customerType>& CQueue,
int numOfCustArrived,
int waitTimeServedCustomers)
{
int customersLeftInQueue = 0;

int totalWaitTime = waitTimeServedCustomers;

customerType customer;

while (!CQueue.empty())
{
customer = CQueue.front();
CQueue.pop();
totalWaitTime = totalWaitTime + customer.getWaitingTime();
customersLeftInQueue++;
}

double averageWaitTime = 0;

if (numOfCustArrived > 0) // If number of customers arrived is > 0
averageWaitTime = (static_cast<double>(totalWaitTime)) / numOfCustArrived;

cout << fixed << showpoint;
cout << setprecision(2);
cout << "Average waiting time: " << averageWaitTime << endl;
cout << "************** END SIMULATION *************" << endl;
}

// simulation.h

#include <fstream>
#include <string>
#include <queue>